Post

Python 知识点

Posted
By xiaopang
24 min read
Python 知识点

1，Python程序的扩展名，提示符

  • 扩展名：

    1
2
3
4
5

    扩展名：.py , .pyc , .pyo , .pyd 。

.py是源文件，.pyc是源文件编译后的文件，.pyo是源文件优化编译后的文件，.pyd是其他语言写的python库。

知道 .py 和 .pyc 应该就够了

  • 提示符：

    • 1
2
3

        >>>

  请记住 三个，三个，三个 ”>“ 号

2，关于Python在变量声明、创建、释放等内存管理与其他语言的差别

  • 变量声明与创建
    • 变量无需事先声明
    • 变量无需指定类型
    • 程序员不用关心内存管理
    • 变量名会被”回收”
    • del 语句能够直接释放资源
    • 大多数编译型语言，变量在使用前必须先声明，但在 python 中变量在第一次被赋值时自动声明。和其他大多是语言一样，变量只有被创建和赋值后才能被使用；
    • 变量一旦被赋值，就可以通过变量名来访问
  • 内存管理(不确定)

3，Python语言命名规则

  1. 模块（软件包名） ：

    1
2
3
4
5

    模块尽量使用小写命名，首字母保持小写，尽量不要用下划线(除非多个单词，且数量不多的情况)

如：import thisname this_name

不规范：import Thisname

  2. 类名 ：

    1
2
3

    类名使用驼峰(CamelCase)命名风格(尽量)，首字母大写，私有类用一个下划线开头。

如：class Add():   class AddNum():   class_Private():

  3. 函数 ：

    1
2
3

    函数名一律小写，如有多个单词，用下划线隔开。

如：def run():   def add_num():

  4. 变量名 ：

    1
2
3

    变量名尽量小写, 如有多个单词，用下划线隔开。不能使用关键字（python 本身已经使用了的字）或保留字

如：number = 1   school_name = "px"

  5. 常量 ：

    1
2
3

    常量使用以下划线分隔的大写命名。

如：MAX__NUN = 100

4.Python的多行注释方式

  • 1
2
3
4
5
6
7
8
9

      # 三个单引号 或 三个双引号
  如：
  '''
  这是多行注释
  '''

  """
  这也是多行注释
  """

5.浮点数的科学计数法表示

1
2
3
4

使用字母 e 或 E 作为幂的符号，以 10 为基数

如：4.3e-3 即 4.3*10-3 值为 0.0043
9.6E3 即 9600

6.pow( )函数

1
2
3
4

pow(x, y)
返回的值为 x的y次方
如：pow(3, 2)  得到  3*3 = 9
pow(10, 3)  得到 10*10*10 = 1000

7.round( )函数

1
2
3
4
5
6

round(x, y) # 方法返回浮点数x的四舍五入值。y 为要保留几位小数
如：
round(30.12345)   ->   30
round(-100.123)   ->   -100
round(60.12345, 2)  ->   60.12
round(100.0002, 3)  ->   100.000   ->   100.0

8.字符串s切片操作，如s[3:-3]

1
2
3
4
5
6
7
8

str = "hello the world"
str[x:y] # 取 str 中从 x 开始到 y 的字符, x 从 0 开始，y 如果从后往前 从 -1 开始
如：
str[0:2]   ->   "he"
str[:3]    ->   "hel"
str[1:]    ->   "ello the world"
str[0:-1]  ->   "hello the world"
str[:-6]   ->   "hello the"

9.python代码块以缩进区分

1
2
3
4

def add():
    # 这是函数体内
    pass
# 这是函数体外

10.lambda函数，参数和函数体，返回值

  • 当我们想要使用一个简单定义的，或者只需要调用一两次的函数时，取名就是一个比较麻烦的事, 使用lambda()匿名函数可以省去这一步骤
  • 1
2
3
4
5
6
7
8

      #x是传入的参数
  a = lambda x : x*10
  print(a(1))   #10
  """
  相当于
  def a(x):
  	return x*10
  """

11.print %格式化或format格式化两种方式

python格式化输出的三种方式 (o゜▽゜)o☆_

% 格式化

符号  
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%o 格式化八进制数（不能带小数点）
%x 格式化十六进制数（不能带小数点）
%f 格式化浮点数，可以控制保留小数点后几位数
%e 将数字转化成科学计数法的形式 
1
2
3
4
5

name = "lucy"
age = 18

# %格式化
print("my name is %s, i am %d years old" % (name, age))

format 格式化

模板 ： print(‘xxx{}x{}x’.format(x,y))

{} 中常用方法

模板 输出结果
{:a<3} <样式型> 用a填充满长度为3的字符串且转义的内容靠左(<^>分别表示靠左上右)
{:f} <功能型> 将我们的数据类型转换成浮点类型的数据（默认保留小数后6位）
{:.a} <样式型> 控制浮点数据保留a位小数
{:+} <样式型> 用于显示数据的正负号
{:e} <功能型> 将数字转化成科学计数法的形式
{:%} <功能型> 将我们的数据转换成百分制的形式输出
{:b} {:d} {:o} {:x} <功能型> b、d、o、x 分别是二进制、十进制、八进制、十六进制 
1
2
3
4
5

name = "lucy"
age = 18

# format 格式化
print("my name is {}, i am {} years old".format(name, age))

IPO（Input Processing Output）模式包含哪些部分

  • python第二课：IPO模式
  • I：input–输入，程序的输入（文件输入、网络输入、用户手工输入、随机数据输入、程序内部参数输入等）就像我们例子中的的前两行：从键盘上接收两个数a和b，这个过程就是输入过程。（由于input一般接受 str（字符串）类型的，所以需要使用 eval 函数去掉接收字符串两边的引号，使其变为整数类型）
  • P：process – 处理，算法，程序的主要逻辑（程序对输入进行处理输出产生结果；处理的方法也叫算法）这是一个程序的灵魂，程序可以解决很多问题，解决的问题有一个，但是解决的方法有无数个，这些方法就是我们的处理过程，就像我们上面的例子中的第三行：s = a+b 将a与b相加之和通过赋值符号“=”赋值给s。
  • O：output–输出，程序的输出（屏幕显示输出、文件输出、网络输出、操作系统内部变量输出等）就像上面的例子中的最后一行：将 a 与 b 之和 s 输出。

复数，real, imag各代表哪部分

  • 复数是由 实数 + 虚数 组成，如：x + yi ，
  • 复数由实部（real）和虚部（imag）构成，在 Python 中，复数的虚部以 j 或者 J 作为后缀

  • 具体格式为：

    1

    a + bj  # a为实部(real), b 为虚部(image)

  • 1
2
3
4
5
6
7

      # 实例运算
  a1 = 3 + 2j
  a2 = 2 + 5j
  print(type(a1)) # 输出 a1 的类型，得到 <class 'complex'>
  print(a1 + a2) # 得到 5 + 7j[过程：(3+2) + (2+5)j]
  print(a1 * a2) # 得到 -4 + 19j
  # [乘法过程：(2*3 + 3*5j + 2*2j + 2j*5j) -> (6 +15j + 4j -10)]

字符串比较规则

  • 1
2
3
4
5
6
7
8
9
10
11
12
13

      # 老师说的应该主要是这个
  """
  字符串的比较操作：
  	运算符：>,>=,<,<=,==,!=
  	比较规则:首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，一次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较
  	比较原理:两字符进行比较时，比较的是其ordinal value(原始值),调用内置函数ord可以得到指定字符的ordinal value（ASCII码）。与内置函数ord对应的是内置函数chr,调用内置函数chr时指定ordinal value可以得到其对应的字符
  """

  print('apple'>'app')     # True
  print('apple'>'banana')  # False，就是从第一个字符开始判断 ascll 97(a) > 98(b)
  print(ord('a'),ord('b')) # 得到：97, 98
  print(chr(97),chr(98))   # 得到：a, b
  print(ord('a'))          # 得到：65

  • Python中is和==的区别

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

    '''
== 与 is 的区别
== 比较的是 value
is 比较的是 id 是否相等

只有数值型和字符串型，并且在通用对象池中的情况下，a is b才为True，否则当a和b是int，str，tuple，list，dict或set型时，a is b均为False。
'''

# 补充
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)  # Ture
print(a is b)  # False
print(id(a), id(b))# 得到：1369101717896 1369101718408，内存地址不一样

a = b = [1, 2, 3]
print(a == b)  # Ture
print(a is b)  # Ture
print(id(a), id(b))  # 得到：2195026104712 2195026104712，内存地址一样

while循环的使用

  • Python中while循环讲解【详细】
  • Python教程：while 循环用法讲解
  • 1
2
3
4
5
6
7
8
9
10
11

      # 一般形式
  while 判断条件：
  	执行语句

  # 求和
  n = 0
  sum = 0
  while n <= 100:
  	sum += n

  print(sum)  # 得到：5500(从 1 加到 100)

  • 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

      # while else, 当 while 判断条件为 Flase 时执行 else
  while 判断条件:
  	执行语句
  else:
  	执行语句

  # 例
  n = 0
  while n < 3:
  	print(n)
  	n += 1
  else:
  	print("else")
  """
  输出：
  0
  1
  2
  else
  """

递归调用的终止条件

递归函数停止的条件一般定义在递归函数内部，在递归调用前要做一个条件判断，根据判断的结果选择是继续调用自身，还是 return 返回，停止递归。递归函数停止的条件：

  • 判断递归的次数是否达到某一限定值
  • 判断运算的结果是否达到某个范围等，根据设计的目的来选择
  • 附：python 递归超过一定次数后会抛异常（报错，终止）

文件的读写，尤其是csv文件的读写

  • Python open() 函数
  • 1
2
3
4
5
6
7
8
9

      # 如要打开 D://123.txt
  # 方法一
  f = open("D://123.txt", "w")
  f.write("123")  # 将 123 写入到 123.txt 中
  f.close()

  # 方法二 (不用 close)
  with open("D://123.txt") as f:
  	f.write("123")
  • csv, 是一种逗号分隔 值格式的文件,是一种用来存储数据的纯文本格式文件。CSV文件由任意数目的记录组成,记录间以某种换行符分隔;每条记录由字段组成,字段间的分隔符是其它字符或字符串。
  • 1
2
3
4
5

      #　格式示例

  id,name,age
  0,张三,19
  1,李四,20
  • image-20220828112017382

request请求失败的常用做法

  • 修改请求头数据中的：User Agent：客户端软件类型
  • 1
2
3
4
5
6
7
8
9
10
11
12
13

      # 请求代码
  import requests
  url = "http://www.qq.com"
  data = requests.get(url)

  # python 默认的 请求头
  # host 为请求的地址，那个 qq.com 是我上面写的不管他
  GET / HTTP/1.1
  Host: www.qq.com
  User-Agent: python-requests/2.25.1   # 这个一看就是 python 发的请求,网站就会拦截它
  Accept-Encoding: gzip, deflate
  Accept: */*
  Connection: close

  • 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

      #  所以，将 User-Agent 的值改为近似人去访问
  #  这是用 edge 去访问的 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36

  # 请求代码
  import requests
  url = "http://www.qq.com"
  heads = {
  	"User-Agent": Mozilla/5.0
  }
  data = requests.get(url, headers=heads)

  #  请求头就变成了
  GET / HTTP/1.1
  Host: www.qq.com
  User-Agent: Mozilla/5.0
  Accept-Encoding: gzip, deflate
  Accept: */*
  Connection: close

集合的操作| - ^

  • 集合是无序和无索引的集合。在 Python 中，集合用花括号编写。
  • 集合一旦创建，您就无法更改项目，但是您可以添加和删除项目。
  • 集合中没有相同的元素
  • 1
2
3
4
5
6
7
8
9
10
11
12
13

      a = set('abracadabra')
  b = set('alacazam')

  print(a)  # {'a', 'r', 'b', 'c', 'd'}
  print(b)  # {'a', 'l', 'c', 'z', 'm'}
  # 集合a中包含而集合b中不包含的元素
  print(a - b)  # {'r', 'd', 'b'}
  # 集合a或b中包含的所有元素
  print(a | b)  # {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
  # 集合a和b中都包含了的元素
  print(a & b)  # {'a', 'c'}
  # 不同时包含于a和b的元素
  print(a ^ b)  # {'r', 'd', 'b', 'm', 'z', 'l'}

循环保留字：break、continue的差别和作用

  • break：跳出循环，执行循环以后的外部语句
  • continue：终止本次循环，执行下一次循环
  • 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

      for a in range(10):
  	for b in range(5):
          if a == b:
              print(a, b)
              break
          print("123")
  # 这里在 b 循环内写的 break 会终止这次 b 循环，执行下一条外部语句，就是 a=0 -> a=1 .
  """
  运行后得到:
  0 0（0，0 匹配后面的 b 循环就终止了，后面运行 当 a=1 时的循环）
  123（1，0不匹配）
  1 1
  123（2，0 不匹配）
  123（2，1 不匹配）
  2 2
  ...
  """

  • 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

      for a in range(10):
  	for b in range(5):
  		if a == b:
              print(a, b)
              continue
          print("123")
  # 这里就是 终止 b循环中 当 b=0 时的本次循环，到 b 的下一个循环 即 b=0 ->b=1
  """
  运行后得到:
  0 0（0，0匹配，但后面的 b 循环继续运行，只是结束了本次 b=0 的循环）
  123（0，1）
  123（0，2）
  123
  123（0，4
  123（1，0）
  1 1
  123（1，2）
  123
  ...
  """

伪随机数

  • 首先，没有完全随机的随机数。计算机生成的随机数都是伪随机数
  • 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

      # random 一个产生随机数的函数
  import random

  """
  random.seed()俗称为随机数种子。不设置随机数种子，你每次随机抽样得到的数据都是不一样的。设置了随机数种子，能够确保每次抽样的结果一样。而random.seed()括号里的数字，相当于一把钥匙，对应一扇门，同样的数值能够使得抽样的结果一致。
  这是伪随机数的一种体现
  """


  def randomess():  #未设置随机种子
      rum = random.randint(1, 100)
      print(rum)
  # 调用函数后产生的结果
  randomess()  # 59
  randomess()  # 27

  def random_seed(seed = 1):  #设置随机种子
      random.seed(seed)
      rum = random.randint(1, 100) #抽取从1-100的一个整数随机数
      print(rum)

  random_seed(2)  # 8
  random_seed(3)  # 31
  random_seed(2)  # 8
  random_seed(3)  # 31

python根据命名空间寻找变量过程

  • 局部命名空间 > 全局命名空间> 内置命名空间

  • 命名空间

    1. Python使用叫做命名空间的东西来记录变量的轨迹。命名空间是一个字典(dictionary)，它的键就是变量名，它的值就是那些变量的值
    2. 命名空间可以理解为一个容器。在这个容器中可以装许多标识符。不同容器中的同名的标识符是不会相互冲突的
    3. 命名空间(Namespace)是从名称(变量名)到对象的映射，大部分的命名空间都是通过Python字典来实现的
      1. 命名空间：每一个名称、变量的存储位置，不同位置的变量的使用范围不一致(变量的作用域不一致)
      2. 在Python中三种命名空间，也就是说我们定义的变量等能有三种不同的使用范围(具体是哪种使用范围就需要看变量定义的位置的)
      3. Python中一切皆对象(6中基本数据类型、函数、类等都是对象)，对象都可以使用变量名来进行引用

  • 命名空间的作用

    1. 命名空间提供了在项目中避免名字冲突的一种方法
    2. 各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名(变量名不能重复，重复之后后面的会将前面的覆盖掉：重新赋值)
    3. 但不同的命名空间是可以重名而没有任何影响
  • python命名空间的加载与查找顺序

字典的创建和使用

  • python-字典(创建方式、常用的操作方式)_
  • 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

      # 创建
  """
  通过键值对的方式存储数据：
  key: value
  key 同一个字典内不可以重复
  value 可以重复
  """
  # 一，使用花括号手动创建
  dic = {
  	key1: value,
  	key2: value,
      "name": "张三",
      "age": 18
      18: "123"
  }

  # 使用 dict() 函数创建
  dict(key1=value1, key2=value2)

  # 使用
  dic.get(key)  # 得到 key 所对应的 value，若字典中没有这个 key, 输出 None
  dic.get(key, "备用")  # 若字典中没有这个 kye, 输出 "备用"
  dic.keys()  # 输出 字典中的所有 key
  dic.values()  # 输出字典中的所有 value

用户输入函数

爬取指定html标签下的内容

study, Python
Python
This post is licensed under CC BY 4.0 by the author.