【自留】Python学习笔记

• print print打印对象的内容

  type type输出对象的类型

  dir dir输出对象支持的方法和属性

• 空值None

进制、浮点数、复数、数据类型

• 二进制：以0b或0B做前缀；用bin(x)把x转成二进制，返回值为str

  八进制：以0o或0O做前缀；用oct(x)把x转成八进制，返回值为str

  十六进制：以0x或0X做前缀；用hex(x)把下转成十六进制，返回值为str

  print("二进制{0:b}、十进制{0}（或{0：d}）、八进制{0:o}、十六进制{0:x}".format(0x4DC0+50))
  分别输出0x4DC0+50这个16进制数的各个进制
  

• 超出浮点数上限数据表示为inf；低于下限则表示为0.0

• 复数：

  complex([real[, imag]])
  

  创建一个复数，也可以转换一个字符串的数字为复数，或者转换一个数字为复数。

  如果第一个参数是字符串，第二个参数不用填写，会解释这个字符串且返回复数；第二个参数不能输入字符串。

  real和imag参数可以输入数字，如果imag参数没有输入，默认它就是零值，这个函数就相当于int()或float()的功能

  • 实部和虚部都是浮点数
  • 虚部的后缀可以是 “j” 或者 “J”
  • 复数的 conjugate 方法可以返回该复数的共轭复数

• 六个标准的数据类型：

  Numbers（数字类型）

  Strings（字符串类型）

  Lists（列表类型）

  Tuples（元组类型）

  Dictionaries（字典类型）

  Sets（集合类型）

  **用type( )**来看数据类型。

  **用help()**来查看函数/模块/数据类型用途

• 浮点型转化 ：

  is_integer()：判断是否为小数，小数非零返回False，为零返回True，转换为布尔值。

• 全局变量使用英文大写，单词之间加下划线：全局变量一般只在模块内有效，实现方法：使用__All__机制或添加一个前置下划线。

  私有变量使用英文小写和一个前导下划线：

  内置变量使用英文小写，两个前导下划线和两个后置下划线：

  一般变量使用英文小写，单词之间加下划线：

• 使用变量：

print:

name=Tom
print("Hello %s"%(name))
print("Hello {}".format(name))
print(f"Hello {name}")
//关键字填充
str="年龄:{age}".format(age=18)
print(str)
//字典设置参数，用**展开map集合
info={"age":18}
str="年龄：{age}".format(**info)
print(str)
//
list1=["lisa",18]
str="name={0[0]},age={0[1]},year={1}".format(list1,2022)
print(str)
//多行f-strings
message=(
	f="{"..."}\n"
	f="{"..."}\n")
print(message)
//用字符填充式写法
str="welcome"
print(f"{str:->15}")
//--------welcome
print(f"{str:-<15}")
//welcome--------
print(f"{str:-^15}")
//----welcome----

%s：      作为字符串
%d：     作为有符号十进制整数
%u：     作为无符号十进制整数
%o：     作为无符号八进制整数
%x：     作为无符号十六进制整数，a～f采用小写形式
%X：     作为无符号十六进制整数，A～F采用大写形式
%f：     作为浮点数
%e，%E： 作为浮点数，使用科学计数法
%g，%G： 作为浮点数，使用最低有效数位

print函数输出数据后会换行，如果不想换行，需要指定end=""

• 缩进

  同一个代码块的缩进空格数必须相同。

  一行一条语句，语句之后的分号 ; 可加可不加。但如果要在一行中写多条语句，则需要用分号 ; 隔开每条语句。

• 保留字

  不可作为标识符、变量名、常量名等。输出当前版本所有关键字的代码：

  import keyword            #导入keyword模块
  keyword.kwlist             #调用kwlist显示保留关键字列表
  

• 注释

  单行注释以#开头

  #……#或者‘’‘……‘’'或者"“”……“”"可表示多行注释

  字符串（1）

• 序列：

  正向递增序号由0开始，反向则由-1开始。

区间访问方式，采用[N:M]格式，表示字符串中从N到M（不包含M）的子字符串，正向递增序号和反向可以混用，如[2:-4]

输出可以是：

name=input("请输入姓名")
print(name[0]+"Hello")                           
print("{}，Hello！".format(name[1:])) 

• 转换
  • 转换成整数，使用int()函数
  • 转换成小数，使用float()函数
  • 转换成字符串，使用str()函数
  • 转换成布尔值，使用bool()函数

str = input()
num1 = int(str)
f1 = float(str)
print("整数%d,小数%f" % (num1,f1))

注意Python 中对两个数(整数，浮点数)进行除法运算后，得到的结果是浮点数，所以输出需要使用%f

便捷函数

• 合并

  用+来合并（如果需要，在两个字符串之间可以增加相应的空格）

• 打印时若使用print(name.title())可执行title()的指定操作。即以首字母大写的方式显示每个单词。

  若全改为大写，替换为upper；全改写成小写，替换成lower

  所跟圆括号：方法通常需要额外的信息完成工作。不过此处不需要。

• 去除字符串首尾空格strip( )

  处理后字符串1 = 待处理字符串.strip()

  处理后字符串2=待处理字符.strip(去除的特定字符)

  E.g strip( )去除空格；strip(‘字符串’)

  可以用lstrip&rstrip分别去除左边和右边的空白

• 查找、替换和分割字符串

  find：原字符串.find(待查字符串)，返回子字符串开始的索引值，不在会返回-1

  str1=“……”
  str2=“……”
  str1.index（str2，（开始），（结束））//可设定范围
  

  index：检测字符串中是否包含子字符串，返回子字符串开始的索引值，不在会报异常

  str1=“……”
  str2=“……”
  str1.index（str2，（开始），（结束））//可设定范围
  

  **replace：**原字符串.replace(被替换的，替换的)

  【如 .replace(‘day’,‘time’)将day替换为time】

  原字符串.split(分割关键词)

  如果不提供分隔符，则程序会默认把空格（制表、换行等）作为分隔符。

• 原始字符串r：如果不想让反斜杠发生转义，可以在字符串前面加个r表示原始字符串

  print('D:\note')
  输出了D：
       ote
  print(r'D:\note')
  输出了D:\note
  

  1. 遇到引号同样是需要转义后才可以正确输出
  2. 不能进行转义 原始字符串会认为转义符也是字符串的一部分
  3. 原始字符串不能以 \ 进行结尾。如果必须出现\，用\进行转义并且单独用引号装起来（如’……‘’//‘）
  4. 如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''...'''的格式表示多行内容

• 注意查看每一个：Python 字符串 | 菜鸟教程 (runoob.com)

• bytes类型：对bytes类型的数据用带b前缀的单引号或双引号表示

  x='abc'
  y=b'abc'
  前者是str，后者显示内容相同，但每一个字符只占一个字节
  

1. **表示乘方运算

2. 可用下划线将数字分组，不会打印出下划线

3. 要将特定的变量视为常量，可将其字母全部大写

4. 运算符优先级

5. 下列运算符前后都需使用一个空格：

   = + - < > == >= <== and or not

   下列运算符前后不使用空格：

   * / **

6. is，is not && ==，！=：is或is not判断是指定对象id地址是否相同；==或！=判断的是指定对象的值是否相等。

列表[ ]

1. 用[ ]表示列表，用逗号分割其中的元素。

   number = ['one','two','three']
   

2. 访问任意元素，只需指出位置（索引）。如[0]则是输出第一个元素。（索引从0开始，倒着由-1开始）

3.修改： ……[x]=…… 修改完毕

4.添加元素

• list1 = list(map(int,input().split())) 
  

  由输入得到。

• 使用附加append： 变量列表.append(‘……’)

• 先创一个空白列表 …… = [ ]再一次次用append函数添加

5.删除元素：

• 删除后不再使用,用del语句：del 变量列表[位置]

• 删除后还能继续使用用pop( )：方法pop删除的是列表末尾的元素。

  motorcycles =['honda','yamaha', 'suzuki'] print(motorcycles)
  popped_motorcycle = motorcycles.pop() print(motorcycles)
  print(popped_motorcycle)
  结果是：
  ['honda', 'yamaha', 'suzuki'] ['honda', 'yamaha']
  suzuki
  

  如是.pop(x)，可以弹出列表中任意位置的元素。但是使用后被弹出元素不再在列表中。

• 删除：根据值删除元素用remove( )，但因为remove一次只删除一个值，要将所有特定值的元素删除，要使用while循环

  while ‘x’ in lists：
  	lists.remove('x')
  

• 清空列表：重新创建一个与原列表名相同的空列表的方法。

6.排序

• 用sort( )进行永久排序【按照字母顺序】

  print(a.sort())是不行的，要拆开，这样只会得到None
  True降序，False升序，默认升序
  

• 用sorted()进行临时排序【print(sorted(***))】反向同上。

• 反转排列顺序可用reverse()，虽然是永久性，但再次调用就恢复了原样。

7.内置函数:

• 长度：len( )，计算列表元素从1开始。
• 切片[x:x]：可遍历可复制
• 最大值和最小值：max(listname)&min(listname)
• 将元组转换为列表：list(tuple)

8. 用例：

   • 用作堆栈：后进先出，append加入到顶，pop再释放出

   • 列表推导式：

     >>>num=[2,4,6]
     >>>[3*x for x in num]
     [6,12,18]
     //也可叠加多个列表
     

多维列表工具

例子：

list_1 = [('dungeon',7),('winterfell',4),('bran',9),('meelo',6)]
//由元组构成的列表

如要根据数字排序，使用：

list_1 = sorted(list_1,key=lambda x:x[1])

1. lambda 格式：可接受任意数量的参数，但只能有一个表达式，常用作另一个函数里的匿名函数

   x = lambda a，b……：表达式
   print（x（a，b））
   

   和if-else的嵌套：

   x = lambda n:n if (条件1) else (条件2)【可继续嵌套if-else】
   

2. range函数

   squares = [ value **2 for value in range (1,11)]
   //表达式为value**2 ，它计算平方值。 接下来，编写一个for 循环，用于给表达式提供值，再加上右方括
   号
   print(squares)
   

   遍历数字序列，可以使用内置**range()函数。**它会生成数列。注意缩进！！！

   range(start, stop, step)
   对于特殊情况：
   for i in range(10,0,-2):
       print(i,end=' ')
   //10 8 6 4 2
   如果把-2改成2是无法输出的
   

   • start: 计数从 start 开始。默认是从 0 开始
   • stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
   • step：步长，默认为1。两个选取元素之间隔了step-1个元素。
     • 无符号：从左往右，start必须小于end’
     • 负号：从右往左，start必须大于end’
   • 用list可以把range的结果直接转化为列表。即……=list(range(……))

a=[……]
b=a[i:j]
//复制a[i]到a[j-1]，生成新的列表
c=a[i:j:z]
//z意义同上
若为负数，i应该小于j

对于多维数组：

X[:,0]
//取所有行的第0个数据
X[n,:]
//取第一组的全部数值
X[:,m:n]
//取第m到n-1列的数据。

元组（ ）

• 和列表类似，但元素不能修改，用小括号，元素用逗号隔开，字符串要加单引号。

• ……=（x，x）嵌套使用：sample3=(sample1,sample2)

• 只包含一个元素时要在元素后面加逗号，否则会被视为运算符。

• 可以相加进行连接组合，但是不可以修改元素。

• 不允许删除，只能用del ……语句来删除整个元组。

• *乘号是用来复制的。

• sample[x:]指取索引为x的元素之后的所有元素。而sample[x,y,z]指索引从x到y的元素，步长为z。

• if …… in tuple

格式化输出：

alll = ('zhangsan',9,'basketball')
print(alll)
print("he is %s , %d years old,like playing %s "%alll)
//输出结果：
('zhangsan', 9, 'basketball')
he is zhangsan , 9 years old,like playing basketball 

内置函数有：

1. len(tuple)：计算元组元素个数。

2. max(tuple)：返回元组中元素最大值。

3. min(tuple)：返回元组中元素最小值。

4. tuple(iterable)：将可迭代系列（列表）转换为元组。

   >>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
   >>> tuple1=tuple(list1)
   >>> tuple1
   ('Google', 'Taobao', 'Runoob', 'Baidu')
   

字典[ ]：

可存储任意类型对象。

d = {key1: value1 , key2 : value2 ， key3 : value3 }

键和值有单引号，成对出现，中间用冒号分隔，每对直接用逗号分割。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字。创建空字典用{ }即可。

• 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
• 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

推导式：

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

字典的嵌套：

dictname = {键1: {键11: 值11, 键12: 值12 }, 
键2:{ 键21: 值21, 键2: 值22}, 
……, 
键n: {键n1: 值n1, 键n2: 值n2}}

访问字典里的值：把相应的键放入到方括号中。

如tinydict={‘Name’:‘Runoob’} 则输出时用tingydict[‘Name’]

可以用同样格式增加新的键或者值对

**用get（）**来访问值：

dict.get(指定键，指定键不存在时的返回值)，没指定则返回值None

删除：del tinydict[‘Name’] 删除键‘Name’

	  tinydict.clear() **清空字典** 

​ del tinydict 删除字典

追加：sample_dict1[‘键1’]=’值1‘

内置函数：

1. len(dict)
   计算字典元素个数，即键的总数

2. str(dict)
   输出字典，可以打印的字符串表示

3. type(variable)
   返回输入的变量类型，如果变量是字典就返回字典类型

4. items( )遍历

   把字典里所有的键和值一起返回

   for key,value in xxx.items( ):
   
   	print('\nkey:'+key)
   
   	print('value:'+value)
   

5. keys遍历键，values遍历值

补充：

1. 对于copy：浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用。

2. fromkeys的默认值是None

排序：

print(sorted(favorite_languages.items())) //按照键的顺序
print(sorted(favorite_languages.keys()))  //按照键的顺序
print(sorted(favorite_languages.values()))  //按照值的顺序

区分列表索引： A[ : 2 ]与A[ : , 2]的区别

A = [[1,2,3,4,5],
     [6,7,8,9,10],
     [11,12,13,14,15]]

A[ : 2]:表示索引 0至1行；[[1 2 3 4 5],[6 7 8 9 10]]

A[ :, 2]:表示所有行的第3列。[[3 8 13]]

集合（可变&不可变）

一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set()

可变集合：
parame = {value01,value02,...}
或者
parame = set(value)
parame = set([value1，value2……])
parame = set()   //创建空集合一定要用set
不可变集合：
parame =  frozenset([……])

• 可以去掉重复的元素，再用len则得出的是去掉重复元素之后的数量。
• 集合是无序的，因此没有“索引”或者“键”来指定调用某个元素，但可以转为list后使用for循环输出集合的元素

添加元素： parame.add(……) 添加一个元素

​ parame.update(…，…) 添加多个元素

参数可以是列表，元组，字典等

sample_set1.add('python')  //加入了python这个元素
sample_set1.update('python') //加入了’p''y''t'……

移除元素：parame.remove(……) || parame.discard(……)

随即删除：parame.pop()set ——对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

删除集合：del parame

**计算个数：**len（parame）

清空集合：parame.clear()

**判断是否存在：**x in parame 或者 x not in parame

集合运算：A-B为求差集，得出的是A中去掉和B重复部分的值；A|B是求并集；A&B是求交集；A^B是求对称差集，得出的是去掉二者公共部分的值。

差集：z=x.difference(y)，即返回一个集合，元素包含在集合x但不在集合y中。

嵌套

• 在列表里储存字典：

  a ={……}
  b ={……}
  c ={……}
  total = [a,b,c]
  

  排序方法：

  sorted(列表名,key=lambda x:x['键名',reverse=True/False])
  

  根据键值升序or降序

• 在字典中储存列表：

  a = {'first':['one','two','three'],'second':['……','……']}
  

  把两个列表合成一个字典dict(zip())方法：

  keys = ['a','b','c']
  values=[1,2,3]
  dictionary = dict(zip(keys,values))
  

  如果values是一个多级列表：

  values=[[2,'123','567'],[3,'456','789']]
  dictionary =[dict(zip(keys,values)) for row in values]if values else None
  //输出[{'a': [2, '123', '567'], 'b': [3, '456', '789']}, {'a': [2, '123', '567'], 'b': [3, '456', '789']}]
  

• 在字典中储存字典：

  menu_sum = {
      'menu1':{'fish':40, 'pork':30, 'potato':20,'noodles':15},
      'menu2':{'chicken':30, 'corn':55, 'lamb':65,'onion':12}
  }
  

可迭代对象：for ……in……

指存储了元素的一个容器对象，且容器中的元素可以通过__iter__( )方法或__getitem__( )方法访问

常见的可迭代对象包括：
a) 集合数据类型，如list、tuple、dict、set、str等；
b) 生成器，包括生成器和带yield的生成器函数

循环

• while

  while 判断条件(condition)：
      执行语句(statements)……
  

  注意冒号和缩进

  while <expr>:
      <statement(s)>
  else:
      <additional_statement(s)>
  

• **for：**遍历任何可迭代对象，如一个列表或者一个字符串

  for <variable> in <sequence>:
      <statements>
  else:
      <statements>
  

• break：跳出 for 和 while 的循环体，任何对应的循环 else 块将不执行。

• continue ： 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

• pass是空语句，是为了保持程序结构的完整性。一般用做占位语句

迭代器与生成器

前置知识：

1. 迭代：

   python中的可迭代对象有：

   • 集合或序列
   • 文件对象
   • 实现了____iter__()方法的对象。若要在for循环里使用，也要满足iter()调用。

• 迭代器：从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退

  *如果遇到无法随机访问的数据结构如集合时，迭代器是唯一访问元素的方式；

  *在访问到某个元素时才使用该元素。在这之前，元素可以不存在。（很适用于迭代一些无法预先知道元素总数的巨大的集合）。

实现了两个基本的方法就是迭代器：iter() 和 next()。字符串，列表或元组对象都可用于创建迭代器：

list=[1,2,3,4]
it = iter(list)
print(next(it))
//1
print(next(it))
//2
如果是：
for x in it:
	print(x,end=" ")
//1 2 3 4

• 定义迭代器：需要先定义一个类，类里面包含一个iter()函数，这个函数能够返回一个带next()方法的对象。

  def____iter____()

• StopIteration

  用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。如raise stopiteration

  if (循环次数的判断)：
  ……else:
  	raise StopIteration
  

• 生成器（既是可迭代的也是迭代器）

指使用了 yield 的函数。生成器是一个返回迭代器的函数，只能用于迭代操作。

每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

• 三种常用的遍历方式：

  1.普通的for循环遍历：适用于有索引的遍历对象
  2.迭代器遍历：集合所特有的，不常用
  3.增强for循环遍历：使用于数组和Collection集合，也是最简便的遍历方式
  **注意：**这三种遍历方式中，只有1是可以对遍历时原数据作修改，2和3都是不允许在遍历时修改原数据的，只能遍历输出。

遍历内存里的字节，若不用迭代器直接删除会出现碎片，不安全，出现了错误。在迭代器里删除则没事

函数：

• 自定义函数def

  def 函数名：
      函数内容
      return
  

  函数名就是标识符,命名要求与变量命名要求一样
  ● 语句块必须缩进,预定4个空格
  ● 若没有return,会隐式返回一个None值
  ● 定义中的参数列表称为形式参数,只是一种符号标识符

调用的方式：函数名后加上小括号，如有必要在括号内填写上参数

可更改对象和不可更改对象：

字符串、元组和整数不可更改，列表和字典可更改。在函数内部修改时后者会影响外部的对象。

函数&模块

• 导入整个模块：

  模块是扩展名为.py的文件，先要创建一个包含函数的模块。

//pizza.py
def ……
//在pizza.py所在的目录创建另一个.py的文件，导入模块
import pizza
//可以调用函数了
//换个写法，加句点
模块名.函数名

• 导入特定的函数

frome 模块名 import 函数1，函数2……
//无须句点

• 指定别名as

from pizza import make_pizza as mp
//把函数make_pizza()重命名为mp()

也可以给模块指定别名

import 模块名 as 别名

• 导入模块里所有函数

from 模块名 import *

*把模块中每一个函数都复制到了该程序文件中，此时可用名称调用。

• 函数返回类型：

1. 无参无返回值函数：

def print_()：
    print("……")

一般在函数内部会有输出语句或绘图语句，函数返回值为None，调用时不需要赋值语句或print函数。

​ 2.无参有返回值函数：

用return把函数结果返回，调用函数时可以用print直接输出函数处理结果，或用赋值语句为返回值命名。

def sayhi():
	return '字符串'
if __name__ == '__main__':
	print(sayhi())

 3. 有参有返回值函数
    4. **多参函数**
    5. **任意数量实参**：注意如下代码：

names = input().split(' ')
def say_hi_multi_parameter(*names):
    i = 0
    wenhou = []
    for i in range (len(names)):
        name = str(names[i])
        print(f"{name}，你好！")

say_hi_multi_parameter(*names)

上面用了星号下面调用函数的时候也要*，不过这道题不用星号其实也可以。但也有情况：

def plus(*numbers):
   add = 0
   for i in numbers:
      add += i
   return(add)

d1 = plus(1,2,3)
d2 = plus(1,2,3,4)
# 向函数中可以传递任意参数，包括0个参数

# 输出结果
print(d1)
print(d2)

• 变量：
  1. 特殊变量：______xxx______这种格式是允许被直接引用的特殊变量。
  2. __xxx和 _xxx这种格式的函数和变量就是非公开的，不应该被直接引用。

**_xxx的函数和变量是protected，我们直接从外部访问不会产生异常。__xxx的函数和变量是private，我们直接从外部访问会报异常，我们要注意前缀符号的区别。

非公开的函数和变量不能被直接引用。private函数的作用是隐藏函数的内部逻辑，增加函数的封装性。

总结：一般把外部需要使用的函数定义为public函数，而把只在内部使用而外部不需要引用的函数定义成private函数。

• 必选参数&默认参数

def plus(a,b=2)
a为必选参数，必须传入数值，但b是默认参数，如果不传入数值则默认为2.

1. 某一个形参是可选的

def name(first_name,last_name,middle_name=' ')
middle_name是可选的，默认值设置为了空字符串

也可以将默认值设置为特殊值=None（表示变量没有值），将其视为占位值，条件测试时相当于False。

2.禁止函数修改列表：传递列表的副本

(list_name[:])

[:]切片表示法，创建了列表的副本。

• 可变参数：

*（numbers）

创建了一个名为numbers的空元组，将收到的所有值封存在该元组中。如要在函数中打印，可：

for number in numbers:
	printf(f"-{numbers}")

通用形参名*args也收集任意数量的位置实参。

• 关键字参数：（**numbers）的两个星号创建了一个空字典，也可以用于传入：

def plus(x,y,z):
   return x+y+z

dict = {'x':1, 'y':2, 'z':3}
# 用关键字参数的方法将dict列表中的3个值传入plus函数中
d = plus(**dict)

print(d)

使用的过程中是有顺序的，为必选参数、默认参数、可变参数和关键字参数

• 单独出现星号

  def f(a,b,*,c)
  // *后的参数必须用关键字传入
  f(1,2,c=3)
  

• 需要熟记的常用函数：

  1. abs( ):返回绝对值

  2. divmod( ):返回两个数的商和余数。（divmod(7，2)返回(3，1))

  3. max( ):返回元素中最大值

     （max(2,3,8,9,……)

  4. min( ):返回元素中最小值，同上

  5. sum( ):返回传入的元素之和。格式可为：

  sum((1,2,3,4))
  10
  sum([1,2,3,4])
  10
  sum((1,2,3,4),-10)
  0
  

  类型转换：

  1. bool( ):根据传入的参数的逻辑值创建一个新的布尔值。

     bool( )和bool(0)为False，其余一般为True

  2. complex( ):根据传入的参数创建一个新的复数

  complex([real[, imag]])
  real -- int, long, float或字符串；
  imag -- int, long, float；
  

  例子：
  complex()
  0j
  complex('2+4j') //不加引号似乎也可以，但+号两边不可以有空格
  (2+4j)
  complex(1,2)
  (1+2j)
  

  序列操作：

  1. all( ):判断可迭代对象的每个元素是否都为True值

  >>> all([1,2,3])   
  True
  >>> all([0,1,2])     # 列表中0的逻辑值为False
  False
  >>> all(())     # 空元组
  True
  

  2.any( ):判断可迭代对象的元素是否有为True值的元素

  3.sorted( ):对可迭代对象进行排序，返回一个新的列表。

  对象操作：

  1. help( ):返回对象的帮助信息
  2. dir( ):返回对象或者当前作用域内的属性列表。

  文件操作：

  1. open( ):使用指定的模式和编码打开文件，返回文件读写对象

• lambda函数：匿名函数，不需要return来返回值，函数表达式本身的计算结果就是返回值。

//定义加法
f = lambda x,y:x+y
print(f(1,2))

• map函数：接受两个参数，一个是函数，另一个是一个或多个序列。将传入的函数依次作用到传入序列的每个元素，并把结果作为新的序列返回。函数参数数量和传入的序列数量要匹配。

  map(function, sequence[, sequence, ...])
  

  第二个参数中存在多个序列时，会依次将每个序列中相同位置的元素一起做参数。

  a = list(map(int,input().split()))
  print(a)
  ----输出了一个列表
  b = map(int,input().split())
  print(b)
  ----输出了b的地址
  print(*b)
  ----输出了b的内容，非列表形式哦
  c=map(int,input())
  if n not in b:
      print("sorry")
  else:
      print("yes!!!")
  ----可以正常运行
  print(c)
  ----无空格，输出地址
  print(*c)
  ----无空格，输出内容
  

• reduce函数：把传入的函数作用在一个序列上，此函数必须要接受两个参数。reduce函数则把第一次计算的结果和序列的下一个元素做累积计算。

  reduce(function, sequence[, initial])
  

return篇：

1. return多个值时，把值放到元组中。（除非return a，b）
2. 如果有多个并列的return，只执行第一个
3. 结束函数代码块的功能，return之后的下一行语句不会被执行。
4. 如果没有return语句，隐含的返回值是NoneType

if __ name__=='__main __ ':

当前模块被执行，为True，则此式成立，执行接下来的语句。

当你要导入某个模块，但又不想改模块的部分代码被直接执行，那就可以这一部分代码放在“if name==‘main’:”

a = 100

print('你好，我是模块A……')

if __name__=='__main__':

    print(a)
from package01 import A

b = 200

print('你好，我是模块B……')

print(b)

每个模块都有内置的变量__name _ _，模块被直接执行时等于文件名（包含后缀.py）；若该模块import到其他模块中则等于模块名称（不包括后缀）（此时不成立哇）

类

• 创建类（首字母大写）

class 类的名称：
	def __init__(self,a,b):
	//初始化属性a和b
		self.a = a
		self.b = b
	def x(self):
		print(f"{self.a}is...")

类里的函数称为方法。

形参self必须位于其他参数前且不可缺少。而self.a = a获取与形参a相关联的值并赋给变量a，这种通过实例访问的变量称为属性。

方法：

1. 实例方法

   def eat（self）：
   ……
   

2. 静态方法：

   @staticmethod  //修饰
   def method1()：
   ……
   

   不允许加self，即没有任何默认参数。故直接使用类名调用。 类名.静态方法（）

3. 类方法：

   @classmethod  //修饰
   def method2（cls）：
   ……
   

   直接 类名.类方法（）调用，不需要传入参数。

4. 初始化方法

   def __init__(self,name,age)：
   ……
   self,name称为实体属性，进行了一个赋值操作，将局部变量的值赋给了实体属性。
   

属性

1. 类属性：在方法外最先创建的。更改对象也仍然共享

2. 私有属性

   def __init__(self,age,name):
   	self.name=name
   	self.__age=age 
   //不能在类的“外部”被使用
   如：
   print(stu.name) //正常输出
   print(stu.__age) //运行错误
   
   

   如果真的想输出：

   print（dir（stu））
   print(stu.__Student__age)
   //用__类名__名来输出。
   

• 根据类创建实例

对象（example） = 类('name',6)

1. 访问属性：使用句点 example.a
2. 调用方法：同理，example.方法( )，在类中查找了方法并运行。或者 类.方法（对象）【如果调用的方法需要传入self对象……）
3. 创建多个实例：可根据一个类创建任意数量的实例，条件是把每个实例存储在不同变量/列表或字典的不同位置。

• 使用类和实例：

  1. 修改属性的值：

     example.属性名=……，直接修改；

     增加一个方法再赋值；

     通过方法对属性的值进行递增；

• 继承：

  一个类继承另一个类时，将自动获得另一个类的所有属性和方法。原有的类称为父类 ，而新类称为子类 。子类继承了父类的所有属性和方法，同时还可以定义自己
  的属性和方法。

创建子类时，父类必须包含在当前文件且在子类前。

class 子类名（父类名）
	def __init__(self,a,b，c):
	//初始化父类属性
		super().__init__(a,b):
		//调用父类的方法
		self.c=c
多继承
class A（）：
class B（）：
clas C（A，B）：

情况一：**子类需要自动调用父类的方法：**子类不重写__init__()方法，实例化子类后，会自动调用父类的__init__()的方法。

情况二：**子类不需要自动调用父类的方法：**子类重写__init__()方法，实例化子类后，将不会自动调用父类的__init__()的方法。

情况三：**子类重写__init__()方法又需要调用父类的方法：**使用super关键词：

super(子类，self).__init__(参数1，参数2，....)
class Son(Father):
  def __init__(self, name):   
    super(Son, self).__init__(name)

1. 给子类定义属性和方法：

self.c = ……
//直接添加新属性

​ 2.重写父类：

//在子类里：
def 要修改的父类方法（self）：
……
//改写了，但是还想输出父类
def method(self):
	super().method()//调用父类，重写
	……新增内容

3.把实例用作属性：

class 类1：
……
class 类2：
……
class 类3（类2）：
……
self.属性1 = 类1（）

• object类：

  所有没有继承任何类的类，都会默认继承object类。可以用

  print(dir(stu))
  

  来查看继承了object类的哪些方法

  def __str__(self):
  return "字符串……"
  print(stu)
  //输出了上述字符串，因为被重写了
  

• 多态：

  静态语言实现多态的必要条件（java等）：继承、方法重写、父类引用指向子类对象

  然而python是动态语言，所以不用明确继承关系，只要有这个方法就可以

• 导入类

  1. 导入单个类：和模块结合，一个模块中有一个类，然后导入

  from 模块名 import 类名
  

  2.一个模块+多个类：

  3.从一个模块里导入多个类：逗号隔开类名即可

  4.导入整个模块：

  import 模块名
  //使用时：模块名.类名（……）
  

  5.=导入模块中的所有类：

  from 模块名 import*
  

• 也可以使用别名

装饰器

在被装饰的函数定义之后立即运行，被装饰函数只在明确调用时运行。装饰器返回的应该是函数调用fun而非运行结果fun（）。

def outer(fn):
	print("outer")
	def inner():
		print("innner")
		return fn
	return inner //无（）
@outter
---等于把fun函数作为一个参数传入outer，即fun=outer(fun)
def fun():
print("fun")
//输出outer，装饰器约等于调用外部函数，内部函数和装饰函数只是被定义而没有被调用

• @property：将方法转为属性，为只读属性，可以访问但不可修改

  class STU:
  ……
  	@property
  	def area（self）:
  		return……
  student=STU(......)
  

  用student.area可以访问该属性，但不能加小括号

一些别的操作

1. 实现对象的加法：

   class Student:
   ……
   def __add__(self,name):
   	return self.name+other.name
   
   stu1=Student('AA')
   stu2=Student('BB')
   s=stu1+stu2
   print(s)
   //输出的是AABB
   也可以用s=stu1.__add__(stu2)
   

2. 输出对象的长度:

   def __len__(self):
   	return len(self.name)
   

文件操作

1. 文件类型：

   • 文本文件：存储普通字符文本
   • 二进制文件，把数据内容用字节进行存储，如mp3、jpg、doc……无法用记事本打开

2. 编码格式： .py文件使用UTF-8存储，表示1个字符：英文1字节，汉字3字节

3. 文件的读写原理：数据流输入输出同向，读写完文件要关闭资源。

4. 缓冲区：

   全缓冲（空间大小4096字节，也可用Buffering=n（字节），自定义缓冲区大小），

   行缓冲（没遇到一个换行符才调用，Buffering=1）

   无缓冲（把信息实时写入文件时，Buffering=0）

   创建文件对象：

   file=open('filename','mode'，（encoding）)
   mode：打开模式
   encoding：字符的编写格式，r、w、a;b、+与别的格式一起使用
   file.close() //要及时关闭文件并清除文件缓冲区的信息
   

   自动关闭：

   with open(……) as file
   //with语句自动管理上下文资源，会自动close
   

• os模块：

  文件

1. read（[size]）：size为读取字节数，不指定全读取，返回字符串

2. write（）：写入字符串，要人为在字符串末尾加上换行符

3. readline（[size]）：读取整行，size为读取字节数。读取内容包括’\n’

4. readlines（）：读取文件所有行直到EOF，并返回列表（结合for in）

   用
   with open(filename)as file_object:
   for line in file_object:
   	print(line)
   每行的末尾有换行，print会换行，因此要改写成print（line.rstrip())
   

5. rename（原名，新名）：把当前文件名重新命名。

6. remove（文件名）：删除系统中已有文件

7. seek（x，y）：x为开始的偏移量，即需要移动的字节数；y默认为0，**0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起。**移动之后可以继续进行read等操作。

​ 目录

1. os.mkdir（“新建目录名+完整路径”）
2. os.getcwd():显示当前的工作目录路径
3. os.chdir():更改新的工作目录名称，要带目录完整路径
4. os.rmdir():删除目录，要带目录的完整路径

print(os.path.exists(" "))看在不在

split拆分目录和文件

basename提取文件名

print(os.path.basename(’ 路径’))提取出文件名

dirname是提取目录

isdir判断是不是目录

模块

• 以**.py**结尾的独立程序代码的文件

• 命名空间：包含了一个/多个变量名称和它们对应的对象值的字典

  局部变量名与全局变量名重名：函数内部调用屏蔽全局，除非使用global，可以修改函数内全局变量的值

• 导入模块：

  1. import module1，module2，……
  2. from 模块 import 函数1，函数2，……；函数名可用*****导出所有函数
  3. import 模块 as 新名

• 自定义模块：新建以.py为后缀名的文件。该模块与调用的程序要在一个目录

• 检查：

  import modle_name   若成功证明系统已存在此模块，需更改自定义模块名
  

• 自定义包：按目录来组织模块的方法。是一个分层级的文件目录结构，定义了由模块、子包、子包下子包等组成的命名空间。

  1. 每个包目录下必须有一个**init.py**的文件，不然会被认成普通目录
  2. init.py可以是空文件，也可以有代码，是一个模块名为mymodle的模块
  3. 可有多级目录构成多层次的包结构

安装第三方模块

pip <command> [选项]
选项：
install、download、uninstall、freeze……

datetime模块：

from datetime（模块） import datetime（类）
now=datetime.now()//获取了当前时间
或者
import datetime（模块）
print(datetime.datetime.now())  （引用全名）

epoch time：1970.1.1.00：00：00

timestamp:当前时间相对于epoch time的秒数，与时区无关，是一个浮点数，小数位表示毫秒数

dt=datetime(2022,1,1,13,15)
dt.timestamp()
datetime.fromtimestamp(dt)//转回datetime

now=datetime.now()
print(now +(-) timedelta(days=1,hours=23,seconds))更改时刻

from datetime import datetime,timedelta,timezone
utc_8=timezone(timedelta(hours=8)) #创建时区UTC+8:00
now=datetime.now()
或者系统时区不为八时区时（若是，不能强制设置）
now=now.replace(tzinfo=utc_8)
也可以这样时区转换
time=datetime.utcnow()【拿到当前的utc时间】.replace(tzinfo=timezone.utc)     //强制把时区设置成UTC+0:00
changed=time.astimezone(timezone(timedelta(hours=8)))
//换成了北京时间
---得到datetime时间->强制设置时区作为基准->用satimezone转换------

JSON模块

JSON数据格式等同于字典格式

1. dumps、dump：

   dumps：将数据序列化为字符串，无文件操作

   dump：使用时必须传文件描述符，序列化+写入文件

2. loads、load：

   loads：完成反序列化，无文件操作

   load：只接受文件描述符，完成读取文件和反序列化

import json
numbers=[2,3,5,7,11,13]
filename='numbers.json'
with open(filename,'w')as f:
	json.dump(numbers,f) //写入
读出则是：numberss=json.load(f)

sys模块

1. sys.path:包含输入模块的目录名列表，也可：sys.path.append(" ")添加自定义模块路径
2. sys.argv:在外部向程序内部传递参数，该变量包含了命令行参数的字符串列表,利用命令行向程序传递参数。脚本名是 sys.argv 列表的第一个参数。

random模块

1. randint():生成随机整数，也可以加上范围，（下限，上限）

2. random()：生成随机浮点数，同上，但此时下限可以大于上限

3. choice():生成随机字符，choic(‘可选择字符’)

4. shuffle():打乱序列顺序（列表）

   list1=[1,5,3,2,2]
   random.shuffle(list1)
   print(list1) //打乱顺序
   

re模块 (正则表达式)

一个特殊的字符序列，帮助检查字符串是否与某种模式配对。

• 过程：依次拿表达式和文本中的字符比较
• 一旦有不匹配的字符则匹配失败
• 基本字符正则表达式基本语法 (biancheng.net)

1. 实现正则的功能：

   re.match(正则表达式，匹配字符串，【匹配模式】)
   

   “.”的作用是匹配除“\n”以外的任何字符，即在一行内匹配，以“\n”进行区分。

   匹配模式flags：

rw.l	忽略大小写
re.L	表示特殊字符集 \w, \W, \b, \B, \s, \S依赖于当前环境
re,M	多行模式
re.S	包括换行符在内的任意字符在整体中匹配
re.U	表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
re.X	增加可读性，忽略空格和 # 后面的注释

2. 获取匹配表达式:group()或groups()

csv模块

xlrd模块

异常

• 写法

1. try——except：一个try语句可以与多个except语句搭配，其中except块可以写成下面两种形式，Exception是具体的异常类型。try语句检测范围一旦出现了异常，剩下的其它语句将不会被执行

   except：  #可能会掩藏未想到的所有未曾处理过的错误
   except Exception[as reason]:
   except (Exception1,Exception2,…)： #对多个异常进行统一处理
   

2. try—except—finally：finally中是无论如何都会被执行的代码

3. try—except—else：else中是无异常执行完try语句块里的代码后跳转到else处执行的代码。即无异常时会和try里的语句一起执行。

4. try（with）——except：

   try:
       with <语句> as name:
    [语句块]
   except Exception[as reason]:
   

   这样就不用写finally语句了，减少代码量

• 自定义异常:

  1. 先自定义一个异常类，在代码中用raise抛出

  class MyError(Exception):
  ...
  raise MYException（define exceptname）
  #MyException是自定义异常的类型，括号内是自定义异常的说明
  

  2. 结合try—except

     class Myerror(Exception):
     	pass
     try:
         raise Myerror('测试自定义的异常')
     except Myerror as e:
         print(e)
     

绘图

turtle

Matplotlib：

• 绘图种类：

1. 柱状图
2. 圆饼图
3. 折线图

• 子图： subplot(numRows,numCols,plotNum)
• 注释： text()函数可讲文本放在任意位置，而annotate()可以帮助定位
• pylab模块：
• Aritist模块：分为简单类型和容器类型。用该模块创建图表流程如下：创建Figure对象—用Figure对象创建一/多各Axes或Subplot对象—调用Axis等对象的方法创建简单类型Aritists

pandas

• 数据框：类似于二位表，由行列构成，有各自的索引。对数据本身的增、删与对字典的操作类似。
• 函数：

词云图：

• jieba分词包：

  • 分为精确模式、全模式和搜索引擎模式

    str1="..."
    jieba.lcut(str1) //精确模式，返回一个列表类型
    jieba.lcut(str1,cut_all=True)//全模式
    jieba.lcut_for_search(seg_str) //搜索引擎模式
    

  • 如何用jieba统计某个词出现的次数

    words=jieba.lcut(txt)
    counts={}
    for word in words:
    if len(word)==1:  //单个词语不计算在内
    	continue
    else:
    	counts[word]=counts.get(word,0)+1//遍历所有词语，每出现一次其对应的值+1
    	items=list(counts.items())
    	items.sort(key=lambda x:x[1],reverse=True) //按照出现次数从大到小
    

• WordCloud词云包

常用库

numpy：

1. 获取列表前N大的索引：argsort

   将列表中的元素从小到大排序后返回相应索引

   import numpy as np
   arr=np.array({...})
   arr.argsort()
   所以最小值取值：arr[arr.argsort()[0]]
   换成-1就是最大值，组合[::-1]、[2:]等就可以得到前N大的值或者索引
   

可能会用到的简单操作篇：

1. n=int(input())
   num=str(n)
   print(int(num[::-1]))
   

把数字反着输出，如果不用int就是纯纯字符串，0能在开头。

num=[(1,2.5),(1.5,3.2),(1.3,4.0)]
y,z = max(num,key = lambda x:x[0]
//找坐标第一个数的最大值组

区分

• & | 与 and or：

  1. a、b是数值变量：前者为位运算，后者依据是否非0

     1 & 2 //2二进制为10，1为01 故运算结果为0
     1 | 2 //输出为3
     1 and 2 //含0返回0，都非0返回后一个值
     1 or 2 //至少有一个非0时返回第一个非0
     

  2. a、b是逻辑变量，用法基本一致，判断True和False

  3. 需要求得满足多个逻辑条件的数据时，要使用& 和|

• copy,deepcopy拷贝

  import copy
  a=[...[1，1]]
  b=a
  c=copy.copy(a)
  d=copy.deepcopy(a)
  a.append(5)
  

  a与b指向的是同一个值；c作为浅拷贝只拷贝了父对象，若父对象变化c不变，但子对象变化c会变(如改变[1,1])）；d作为深拷贝，a进行任何操作都不改变d

• 命名方式

  1. x：公用方法

  2. _x:半保护，仅类对象和子类对象自己可以访问的变量，在模块/类外不可使用，不能用from module import*导入

  3. __x:全保护，只有类对象自己可访问。该形式描述的方法父类方法不能轻易被子类方法覆盖，实际上是：

     _classname__methodname
     例如：
     class Rectangle:
         __count = 0
         def __init__(self,width,height):
             Rectangle.__count += 1
             self.__width = width
             self.__height = height
     x.Rectangle(100,100)
     可用x._Rectangle__width来强制访问
     同时————count为私有变量，但每次创建对象时值自增1，还是可以统计创建对象个数的。（__init__每次实例化对象的时候自动调用）
     

  4. x:特殊方法

  5. x_:避免与关键词冲突，无特殊含义

• __ new __ 和 __ init __:

  前者是实例对象创建完成后被调用的，然后设置对象属性的一些初始值。后者是实例创建前被调用的，为创建实例并返回该实例。

  __new__是一个静态方法，而__init__是一个实例方法
  __new__方法会返回一个创建的实例，而__init__什么都不返回
  只有在__new__返回一个cls的实例时，后面的__init__才能被调用
  当创建一个新实例时调用__new__，初始化一个实例时用__init__
  

• 静态方法：

  1.属于类，直接由类调用

  2.不能在其方法中调用非静态成员或方法

  3.静态方法加载类时变创建 不需要创建实例对象在创建

  4.一个静态对象共同一块内存 而实例对象则不共用

  静态效率高但是不能自动销毁 实例效率低但能销毁

测试函数——unittest模块

1. 例1，检查函数结果是否正确（一个数据组）

   def get1(first,last):
       fullname=f"{first} {last}"
       return fullname.title()
   //待测函数
   import unittest
   class Names(unittest.TestCase)://必须继承unittest.TestCase类
       def test(self):
       	forma=get1('janis','joplin')      self.assertEqual(forma,'Janis Joplin')//正确结果
   if __name__=='__main__':
       unittest.main()
   

   此测试结果得到一个点，然后OK，一个点证明通过了一个测试，OK表示通过了所有单元测试

2. 一些断言方法

assertEqual(a,b)	核实a==b
assertNotEqual(a,b)	核实a!=b
assertTrue(x)	核实x为True
assertFalse(x)	核实x为False
assertIn(item,list)	核实item在list中
assertNotIn(item,list)	核实item不在list中