Python期末复习

1、注释

• 单行注释 以#开头

• 多行注释 以''' '''三个单引号，或者以""" """三个双引号作为注释

2、变量命名

python的变量命名需要遵循两个规则

• 变量名由英文字母、下划线_或数字组成，并且第一个字符必须是英文字母或下划线。

• 变量名不能是 Python 关键字（又称关键词）。

其中python的关键字为

3、缩进

在 Python 中，对于类定义、函数定义、流程控制语句、异常处理语句等，行尾的冒号和下一行的缩进，表示下一个代码块的开始，而缩进的结束则表示此代码块的结束。

Python 对代码的缩进要求非常严格，同一个级别代码块的缩进量必须一样，否则解释器会报 SyntaxError 异常错误

4、数据输入字符串函数input

str = input("请输入一个整数：")
print(type(str))
​
#输出
请输入一个整数：1
   # 结果为字符串类型

5、字符串解析函数eval的使用，特别注意输入字符串可直接解析为组合数据类型

arr = eval(input('请输入一个数组：'))
print(arr)
print(type(arr))
​
# 输出
请输入一个数组：[1,2,3,4]
[1, 2, 3, 4]

6、输出函数print()，默认是换行输出，但是可以指定end参数使其结束符号自定义

print("不打印换行：")
for i in range(1,5):
    print(i,end=',')
    
# 输出
不打印换行：
1,2,3,4,

7、Python中的变量、数据类型、赋值语句

一、变量

• 变量不必事先声明、无须指定类型、直接赋值使用

• 变量及关键字区分大小写，字母下划线开头

• 变量名可以使用中文

二、数据类型

Python有最常用的5个标准数据类型：

• Numbers（数值）

• String（字符串）

• List（列表）

• Tuple（元组）

• Dictionary（字典）

三、赋值语句

• 多变量赋值

• 列表赋值传地址（涉及深拷贝与浅拷贝问题）

  • 浅拷贝：会创建新的对象，但是新对象的赋值只是原对象的地址

  • 深拷贝：会生成新的对象，在新的对象上修改属性值不会影响到原变量【调用copy.deepcopy()函数】

# 单变量赋值
x = 1
a = x
print(a)
​
# 多变量赋值
a,b,c = 1,2,3
print(a,b,c)
​
# 输出
1
1 2 3
​
# 列表赋值  
a = [1,2,3]
b = a  # 浅拷贝
b = b = copy.deepcopy(a)  # 深拷贝

8、各算数运算符：+、-、*、/、%及应用

9、实型数据精确到小数点后15位，精确计算用到math库

a = 1.1
b = 2.2
print(a+b)
​
# 输出
3.3000000000000003

10、和数值运算相关的主要内置函数：sum、max、min、round、pow

a = [1,2,3,4]
b = 2.3444
c = 2
print("sum函数{}".format(sum(a)))   # 计算列表值总和
print("max函数{}".format(sum(a)))   # 计算列表最大值
print("min函数{}".format(sum(a)))   # 计算列表最小值
print("round函数{}".format(round(b,2)))   # 根据指定位数进行四舍五入
print("pow函数{}".format(pow(c,2)))    # 乘方
​
# 输出
sum函数10
max函数10
min函数10
round函数2.34
pow函数4

11、类型转换函数:int(字符串,进制)、float()、list()、set()、dict()

跟C++的强制类型转换有点相似

12、字符串的索引、切片、修改

python的字符串其实可以看做是字符数组，索引和切片都可以按照数组的处理方式进行，但是修改不行。python的字符串不可以通过索引修改，只能调用replace函数

str = "Python"
# 索引
for i in str:
    print(i,end=',')
print()
​
# 切片
print(str[0:2])
​
# 修改
print(str)
str[2] = 'Y'   # 会报错
print(str)
​
# 输出
P,y,t,h,o,n,
Py
Python
报错

13、内置字符串处理函数str、len

str强制转换为字符串类型，len计算字符串、列表等长度

a = 3
str = str(a)
print(str)
print(type(str))
print(len(str))
​
# 输出
3

1

14、字符串处理常用方法：split()、join()、replace()、center()、strip()

• Python split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串

• Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

• Python replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

• Python center() 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。默认填充字符为空格。

• Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。

  • 注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。

str = '1,2,3,4,5'
a = ['P','y','t','h','o','n']
list = str.split(',')   # 按照指定的字符分割字符串成字符串列表
print("list = ",list)
str1 = ','.join(a)    #  按照给定字符将字符串列表进行拼接
print("str1 = ",str1)
str2 = str1.replace('y','C')   # 进行字符替换
print("str2 = ",str2)
str3 = str1.center(15,'*')   # 进行左右填充
print("str3 = ",str3)
str4 = '    java'
print("str4 = ",str4.strip())  # 移除头尾指定字符，未指定则为空格或者换行

# 输出
list =  ['1', '2', '3', '4', '5']
str1 =  P,y,t,h,o,n
str2 =  P,C,t,h,o,n
str3 =  **P,y,t,h,o,n**
str4 =  java

15、格式化输出方法format()

跟c语言的printf基本一致，格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

format 函数可以接受不限个参数，位置可以不按顺序。

print('{0} {1} {0}'.format("python","java"))
print('{:.2f}'.format(3.1415))

# 输出
python java python
3.14

16、For循环进行各种迭代

遍历结构可以是字符串、文件、组合数据类型或range()函数

for循环主要考察python的列表推导式

一、用法

for i in range(1,3):
    print(i,end=' ')

# 输出
1 2

二、列表推导式

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

Python 支持各种数据结构的推导式：

• 列表(list)推导式

• 字典(dict)推导式

• 集合(set)推导式

• 元组(tuple)推导式

# 列表推导式
names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
new_names = [name.upper() for name in names if len(name)>3]
print(new_names)
number = [i for i in range(30) if i %3==0]
print(number)
# 输出
['ALICE', 'JERRY', 'WENDY', 'SMITH']
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

# 字典推导式
ames = ['Bob','Tom','alice','Jerry','Wendy','Smith']
new_ams = {i:len(i) for i in ames}
print(new_ams)
# 输出
{'Bob': 3, 'Tom': 3, 'alice': 5, 'Jerry': 5, 'Wendy': 5, 'Smith': 5}

# 集合推导式
setnum = {i**2 for i in range(1,4)}
print(setnum)
# 输出
{1, 4, 9}

# 元组推导式
tuplearr = (x for x in range(1,10))
print(tuple(tuplearr))
# 输出
(1, 2, 3, 4, 5, 6, 7, 8, 9)

17、While循环

循环中else子句、continue、break的使用，这个基本都是编程语言都有的

i = 5
while(i>0):
    print(i,end=' ')
    i-=1
# 输出
5 4 3 2 1

18、分支语句

• 单分支

• 双分支

• 多分支

19、random库的使用

随机数生成方法：random、randint、randrange

• random生成随机数

• Python random.randint() 方法返回指定范围内的整数。

• randint(start, stop) 等价于 randrange(start, stop+1)。

注意：randint 【左闭右闭】 randrange 【左闭右开】

import random
print(random.random())  # 生成一个[0,1)的随机浮点数
print(random.randint(1,9))  # 生成一个[1,9]的随机整数
print(random.randrange(1,9))  # 生成一个[1,9)的随机整数

# 输出
0.0634119049812043
3
5

20、函数的定义、调用、参数传递（传值、传地址）、可变参数应用（打包传递）

一、定义

• def开头

• 参数可加可不加，return可加可不加

• 冒号表示函数开始，缩进表示整体函数块

def func(a):
    print(a)
    return a

二、参数传递

注意：在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

在python函数传值中

• 对于可变类型作为参数时，传入python函数相当于C++的引用传递，函数内改变参数值会直接导致函数值发生改变

• 对于不可变类型作为参数时，传入python函数相当于C++的值传递，函数内改变参数并不会影响到函数外的值

def func(a):
    a.append(1)

a = [1,2,3,4]
func(a)
print(a)

# 输出
[1, 2, 3, 4, 1]

三、 Python函数可变参数*args及**kwargs

参考博客：(36条消息) 【Python】*args 和 **kwargs的用法【最全详解】python *args用法春风惹人醉的博客-CSDN博客

args 是 arguments 的缩写，表示位置参数；kwargs 是 keyword arguments 的缩写，表示关键字参数。

• *args 表示任何多个无名参数， 他本质上是一个 tuple。形象点来说，这东西跟无底洞一样，你来多少要多少

• ** kwargs 表示关键字参数， 它本质上是一个 dict。形象点来说，这东西也跟无底洞差不多，但是它只接收字典

注意：同时使用时必须要求 *args 参数列要在** kwargs 前面 【因为位置参数在关键字参数的前面。】

1、*args 的用法

用来接收不知道有多少数量的参数给一个函数，预先并不知道，函数使用者会传递多少个参数给你，所在在这个场景下使用这两个关键字。 * args 是用来发送一个 非键值 的可变数量的参数列表给一个函数。

#Case 1
def test_var_args(f_arg, *argv):
    print("first normal arg:",f_arg)
    for arg in argv:
        print("another arg through *argv:",arg)
test_var_args('yasoob','python','eggs','test')
# 输出
first normal arg: yasoob
another arg through *argv: python
another arg through *argv: eggs
another arg through *argv: test

# Case 2 定义一个打印的函数，传入任意参数即可
def print_func(*args):
    print(type(args))
    print(args)
print_func(1,2,'python希望社',[])
# 输出

(1, 2, 'python希望社', [])

# Case 3 在打印函数的参数处，新增 x 和 y 变量
def print_func(x,y,*args):
    print(type(x))
    print(x)
    print(y)
    print(type(args))
    print(args)
print_func(1,2,'python希望社',[])
# 输出

1
2

('python希望社', [])

# Case4 将 *args 放在参数最前面
# 会导致后面的参数接收不到任何参数传值，因为前面跟个无底洞一样
def print_func(*args,x,y):
    print(type(x))
    print(x)
    print(y)
    print(type(args))
    print(args)
# 输出  这里的x和y压根接收不到参数的传值
TypeError: print_func() missing 2 required keyword-only arguments: 'x' and 'y'

# 改正的代码
def print_func(*args,x,y):
    print(type(x))
    print(x)
    print(y)
    print(type(args))
    print(args)
print_func(1,2,'python希望社',[],x='x',y='y')
# 输出

x
y

(1, 2, 'python希望社', [])

# Case 5 将*args 放在中间，会导致后面的参数接受不到传入的参数的值
def print_fun(x,*args,y):
    print(type(x))
    print(x)
    print(type(args))
    print(args)
    print(y)
print_fun(1,2,'希望工程',3)
# 输出
TypeError: print_fun() missing 1 required keyword-only argument: 'y'

2、** kwargs 的用法

kwargs允许你将不定长度的 【键值对 key-value 】，作为参数传递给一个函数。如果你想要在一个函数里处理带名字的参数，你应该使用kwargs

def print_fun(**kwargs):
    for key,value in kwargs.items():
        print("{0}:{1}".format(key,value),end='   ')
print_fun(a=1, b=2, c='呵呵哒', d=[])
# 输出
a:1   b:2   c:呵呵哒   d:[]   

3、组合使用 args,*args 和 **kwargs 来调用函数

arg,*args,**kwargs ,三者是可以组合使用的，但是组合使用需要遵循一定的语法规则，即顺序为王。

需要按照：

arg,*args,**kwargs 作为函数参数的顺序。

# Case 1
def print_func(x, *args, **kwargs):
    print(x)
    print(args)
    print(kwargs)

print_func(1, 2, 3, 4, y=1, a=2, b=3, c=4)
# 输出
1
(2, 3, 4)
{'y': 1, 'a': 2, 'b': 3, 'c': 4}

# Case 2 
def test_args_kwargs(arg1,arg2,arg3):
    print("arg1:",arg1)
    print("arg2:",arg2)
    print("arg3:",arg3)
# 输出
# 首先你可以使用 *args
args = ("two",3,5)
test_args_kwargs(*args)

#-------- 得到输出结果如下所示：----------------------
# arg1: two
# arg2: 3
# arg3: 5
# ---------------------------------------------------

21、函数调用参数的缺省值

如果在函数定义时，已经给参数赋值，则在调用函数的时候可以选择传入或者传入该参数

def func(a,b = 2):
    print("a = ",a)
    print("b = ",b)
func(1)
print('*'*20)
func(1,3)
# 输出
a =  1
b =  2
********************
a =  1
b =  3

22、Lambda函数的定义与使用

参考博客：(36条消息) Python 之 lambda 函数完整详解 & 巧妙运用_lambda函数python_Nick Peng的博客-CSDN博客

一、Lambda函数的语法

• lambda 函数的语法只包含一个语句，表现形式如下： lambda [arg1 [,arg2,.....argn]]:expression

• 其中，lambda 是 Python 预留的关键字，[arg…] 和 expression 由用户自定义。

二、Lambda特性

• lambda 函数是匿名的：

  • 所谓匿名函数，通俗地说就是没有名字的函数。lambda函数没有名字。

• lambda 函数有输入和输出：

  • 输入是传入到参数列表argument_list的值，输出是根据表达式expression计算得到的值。

• lambda 函数拥有自己的命名空间：

  • 不能访问自己参数列表之外或全局命名空间里的参数，只能完成非常简单的功能。

三、用法

1、常见函数

lambda x, y: x*y			# 函数输入是x和y，输出是它们的积x*y
lambda:None					# 函数没有输入参数，输出是None
lambda *args: sum(args)		# 输入是任意个数参数，输出是它们的和(隐性要求输入参数必须能进行算术运算)
lambda **kwargs: 1			# 输入是任意键值对参数，输出是1

2、常见用法

add = lambda x,y: x+y
print(add(2,3))
# 输出
5

3、高阶函数

# 1、map函数
# ===========一般写法：===========
# 1、计算平方数
def square(x):
	return x ** 2

map(square, [1,2,3,4,5])	# 计算列表各个元素的平方
# 结果：
[1, 4, 9, 16, 25]

# ===========匿名函数写法：============
# 2、计算平方数，lambda 写法
list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))
# 结果：
[1, 4, 9, 16, 25]	 

# 3、提供两个列表，将其相同索引位置的列表元素进行相加
list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))
# 结果：
[3, 7, 11, 15, 19]

-----------------------------------------------------------------------------
# 2、sorted()函数
# ===========一般用法：===========
# 1、简单排序
a = [5,7,6,3,4,1,2]
b = sorted(a)       # 使用sorted，保留原列表，不改变列表a的值
print(a)
[5, 7, 6, 3, 4, 1, 2]
print(b)
[1, 2, 3, 4, 5, 6, 7]

# ===========匿名函数用法：===========
L=[('b',2),('a',1),('c',3),('d',4)]
# 2、利用参数 cmp 排序
sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))
# 结果：
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
# 3、利用参数 key 排序
sorted(L, key=lambda x:x[1])
# 结果：
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

# 4、按年龄升序
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2])
# 结果：
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
# 5、按年龄降序
sorted(students, key=lambda s: s[2], reverse=True)
# 结果：
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

-----------------------------------------------------------------------------
# 3、filter() 函数：
# 描述：
# filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
# ===========一般用法：===========
# 1、过滤出列表中的所有奇数
def is_odd(n):
	return n % 2 == 1
		 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(list(newlist))
# 结果： [1, 3, 5, 7, 9]

# ===========匿名函数用法：===========
# 2、将列表[1, 2, 3]中能够被3整除的元素过滤出来
newlist = filter(lambda x: x % 3 == 0, [1, 2, 3])
print(list(newlist))
# 结果： [3]

23、序列类型的12个通用操作符和函数

#字符串 str
s='I just wanna run '
t='lemon tree'

#元组 tuple,元组不能二次赋值，相当于只读列表
tu=('I','just','wanna','run')

#列表 list
list=['I','just','wanna','run']

#12个通用的操作符和函数
# in,如果x是s的元素，返回True，否则返回False
print('I' in s)

# not in,如果x不是s的元素，返回True，否则返回False
print('I' not in s)

# +,连接s和t
print(s+t)

# *,将序列s复制n次 
print(2*s)

# s[i],索引，返回序列的第i个元素 
print(s[0])

# s[i:j]分片，返回包含序列s第i到j个元素的子序列(不包含第j个元素)
print(s[0:6])

# s[i:j:k]步骤分片，返回包含序列s第i到j个元素以k为步数的子序列
print(list[::2])

# len(s),序列s的元素个数（长度)
print(len(s))

# min(s),序列s中的最小元素
print(min(s))

# max(s)，序列s中的最大元素
print(max(s))

# s.index(x,i,j)序列s中从i开始到j位置中第一次出现元素x的位置
print(s.index('n',0,13))

#序列s中出现x的总次数
print(s.count('n'))

24、组合数据类型相关的内置函数：sorted()（sort()的差别）

• sort()：只针对列表，对原列表排序，返回为空

• sorted()：各种组合类型都可以排，返回为排好序的列表，原来数据无变化

25、列表创建、索引、访问与切片

• 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

• Python有6个序列的内置类型，但最常见的是列表和元组。

• 序列都可以进行的操作包括索引，切片，加，乘，检查成员。

• 此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

• 列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

• 列表的数据项不需要具有相同的类型

list1 = [i for i in range(1,8)]   # 通过列表推导式创建列表
print("通过索引访问列表值：",list1[3])  # 通过索引访问列表值
print("列表切片：",list1[1:5])   # 列表切片

# 输出
通过索引访问列表值： 4
列表切片： [2, 3, 4, 5]

26、列表中的常用方法:sort()、append()、pop()、insert()、remove()

list1 = [i for i in range(1,8)]   # 通过列表推导式创建列表

list1.sort(reverse=True)   # 列表倒叙排序，其中列表的sort函数是没有返回值的，也就是该函数的调用是在原列表上进行的
print(list1)
# [7, 6, 5, 4, 3, 2, 1]

list1.append(3)   # 列表末尾压入
print(list1)
# [7, 6, 5, 4, 3, 2, 1, 3]

list1.pop(2)  # 默认将列表的队尾元素弹出，可以指定弹出元素的索引
print(list1)
# [7, 6, 4, 3, 2, 1, 3]

list1.insert(3,9)   # 在列表指定位置上压入值 其中第一个参数就是指定的位置，第二个参数是要压入的值
print(list1)
# [7, 6, 4, 9, 3, 2, 1, 3]

list1.remove(4)  # 指定要弹出的列表元素
print(list1)
# [7, 6, 9, 3, 2, 1, 3]

27、元组的创建

• Python 的元组与列表类似，不同之处在于元组的元素不能修改。

• 元组使用小括号，列表使用方括号。

• 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

注意：

• 特别注意元组的元素不能修改、追加等

• 但是元组中的元素如果是可修改变量，如列表，则可以对其进行修改操作，修改后的元组也会发生相应的改变

# 元组
tup = () # 创建空元组
tup1 = tuple((i for i in range(1,5)))   # 在用元组推导式创建元组时，若只加一层括号，则会导致报错，
tup2 = tuple((i for i in range(6,10)))   # 因为只加一层括号的推导式编译器并不会认为这是要创建元组的意思，只会认为这是优先级的运算
print(tup1)
print(tup2)

tup3 = (1,2,[3,4,5],'小明','Python')  # 可以修改元组中的可变元素
tup3[2][2] = 4
print(tup3)

# 多变量赋值
a,b,c = 1,2,3
print(a,b,c)
# 这个过程其实可以转换为
(a,b,c) = (1,2,3)
print(a,b,c)

28、内置zip函数的用法

• zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

• 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

• zip()很灵活，如果几个参数不等长，那么它会取最短的那个参数的长度，然后再进行处理。至于那些超出最短长度的成员，就只好被舍弃掉了。

a = ['a','b','c','d']
b = [i for i in range(1,6)]  # [1, 2, 3, 4, 5]
result = list(zip(a,b))  # 压缩
print(result)
# 解压
origin = list(zip(*result))   # 返回一个二维矩阵
print(origin)

# 构建字典
names = ['John', 'Amy', 'Jack']
scores = [98, 100, 85]  # 分数和名字是一一对应的
stu = dict(zip(names,scores))
print(stu)

# 可以把字符串看做压缩后的结果再对其进行解压，就能得到他们每一位上的字母拆分出来后的元组
str = ["flower","flow","flight"]
print(list(zip(*str)))

29、集合的概念和创建方式

• 集合（set）是一个无序的不重复元素序列。

• 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

• 集合是一个可以修改的变量类型，可以为其添加或者删除元素

# 创建空集合
temp = {}  # 注意这是在创建一个空字典
print(type(temp))
# 
temp = set()   # 这是在创建一个空集合  只有这一种方法创建空集合
print(type(temp))
# 

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(set(basket))    # 用集合去重
# 输出
{'apple', 'banana', 'orange', 'pear'}

30、集合元素操作方法

集合并交差、元素添加add()、删除remove()

a = set('abracadabra')
b = set('alacazam')
print(a,b)
# {'d', 'b', 'c', 'a', 'r'} {'z', 'l', 'c', 'm', 'a'}
# 集合的并交差补
print(a|b) # 并
# {'z', 'd', 'l', 'b', 'c', 'm', 'a', 'r'}

print(a&b) # 交
# {'a', 'c'}

print(a-b) # 差
# {'d', 'r', 'b'}

print(a^b)  # 补
# {'z', 'd', 'm', 'l', 'b', 'r'}

print(a)
a.add(9)  # 在集合中添加一个元素
print(a)
a.remove('d')  # 删除指定元素
print(a)
# 输出
{'c', 'r', 'b', 'a', 'd'}
{'c', 'r', 9, 'b', 'a', 'd'}
{'c', 'r', 9, 'b', 'a'}

31、字典的创建、字典中对键的要求

（1）对键的要求：

• 键必须是不可变的变量，如列表、字符串、元组

• 键必须是唯一的，不能有重复。如果有重复，则后面的键所对应的值会覆盖掉前面的键所对的值

# 创建空字典
dict1 = dict()
dict2 = {}
randomdict = {i:random.randint(20,30) for i in range(1,10)}   # 字典推导式创建字典
print(randomdict)
# 输出
{1: 28, 2: 28, 3: 28, 4: 26, 5: 24, 6: 29, 7: 24, 8: 23, 9: 20}

（2）利用zip生成字典（将两个列表）

a = [i for i in range(1,6)]
b = [i for i in range(6,11)]
zip_dict = dict(zip(a,b))   # 用zip函数创建字典
print(zip_dict)
# 输出
{1: 6, 2: 7, 3: 8, 4: 9, 5: 10}

（3）字典中的成员判断in

Python 字典 in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。

而 not in 操作符刚好相反，如果键在字典 dict 里返回 false，否则返回 true。

print(1 in zip_dict)
# 输出
True

（4）字典元素的添加

zip_dict[6] = 11
zip_dict.update({7:12})
print(zip_dict)
# 输出
{1: 6, 2: 7, 3: 8, 4: 9, 5: 10, 6: 11, 7: 12}

（5）字典中的get()方法

score = {'张三':88,'李四':90,'王五':95}
num1 = score.get('张三')  #  get函数，通过键获取对应值
num2 = score.get('赵六',0)  # 若键没找到，则返回0
print(num1,num2)
# 输出
88 0

（6）字典元素的迭代方法：items()、keys()、values()

• 注意不使用这三个方法，直接针对字典元素的操作是对键的操作

# 键的迭代
for item in score:
    print(item,end=' ')
for key in score.keys():
    print(key, end=' ')
# 输出
张三 李四 王五

# 值的迭代
for value in score.values():
    print(value,end=' ')
# 输出
88 90 95

# 键值对的迭代
for item in score.items():
    x,y = item
    print('{}: {}'.format(x,y),end=' ')
# 输出
张三: 88 李四: 90 王五: 95 

32、列表推导式、集合、字典生成式（包括其中的判断条件进行选择）

# 列表推导式
listnum = [i for i in range(1,10) if i%3==0]
print(listnum)
# 输出
[3, 6, 9]

# 集合推导式
setnum = {"film"+str(i) for i in range(1,10)}
print(setnum)
# 输出
{'film1', 'film9', 'film3', 'film4', 'film5', 'film7', 'film6', 'film2', 'film8'}

# 字典推导式
dictnum = {"stu"+str(i): ["course"+str(j) for j in range(1,3)] for i in range(1,4)}
print(dictnum)
# 输出
{'stu1': ['course1', 'course2'], 'stu2': ['course1', 'course2'], 'stu3': ['course1', 'course2']}

33、文件的类型、打开方式（读、写、追加）及相应指针位置

（1）文件的类型由文件的扩展名来确定，例如 .txt 表示文本文件，.csv 表示逗号分隔值文件，.py 表示Python脚本文件等。

（2）以下是常见的文件打开方式及其相应的模式和指针位置：

1. 读取文件（Read Mode）：

   • 打开方式：open('file.txt', 'r')

   • 模式：'r'

   • 指针位置：开头（文件起始位置）

2. 写入文件（Write Mode）：

   • 打开方式：open('file.txt', 'w')

   • 模式：'w'

   • 指针位置：开头（文件起始位置）

   • 注意：如果文件不存在，将创建一个新文件。如果文件已存在，写入模式将清空文件内容并重新写入。

3. 追加文件（Append Mode）：

   • 打开方式：open('file.txt', 'a')

   • 模式：'a'

   • 指针位置：末尾（文件末尾位置）

   • 注意：如果文件不存在，将创建一个新文件。如果文件已存在，将在文件末尾追加内容。

（3）文件的打开和关闭

• open和close

• 其中with open 打开文件可自动关闭

# 读取文件
file = open('file.txt', 'r')
file.seek(0)  # 将指针移动到文件起始位置
data = file.read()
file.close()

# 写入文件
file = open('file.txt', 'w')
file.seek(0)  # 可选步骤：将指针移动到文件起始位置
file.write('Hello, World!')
file.close()

# 追加文件
file = open('file.txt', 'a')
file.seek(0, 2)  # 将指针移动到文件末尾位置
file.write('\nAppended content.')
file.close()

34、异常处理

Python提供了两个非常重要的功能来处理程序在运行中出现的异常和错误。经常使用的是try...except语句，拓展一下就是try-except-else-finally，另一个是断言。

• try：正常情况下，程序计划执行的语句。

• except：程序异常是执行的语句。

• else：程序无异常即try段代码正常执行后会执行该语句。

• finally：不管有没有异常，都会执行的语句。

注意：在try执行完成之后，finally是一定会执行的。即使在try中出现return，finally也会执行！！！

这种特性可以让程序员避免在try语句中使用了return, continue或者 break关键字而忽略了关闭相关资源的操作。把清理相关资源放到finally语句块中一直是最佳实践。

如何做到的呢？

1. try中有return, 会先将值暂存，无论finally语句中对该值做什么处理，最终返回的都是try语句中的暂存值。

2. 当try与finally语句中均有return语句，会忽略try中return。

35、文件的读写

• f.read() ： 该方法用于读取整个文件的内容，并将其作为字符串返回。可以使用可选的参数来指定要读取的字节数。

• f.readlines()：方法用于逐行读取文件的内容，并返回一个包含每行内容的列表，每行内容作为一个字符串元素。

• f.write()：该方法用于向文件中写入字符串内容。它会将给定的字符串写入文件的当前指针位置，并返回写入的字符数。

• f.writelines()：该方法用于向文件中写入多行内容。它接受一个包含字符串的可迭代对象作为参数，并将每个字符串写入文件的当前指针位置。

file = open('file.txt', 'r')
content = file.read()  # 读取整个文件内容
file.close()

file = open('file.txt', 'r')
lines = file.readlines()  # 逐行读取文件内容，返回一个列表
file.close()

file = open('file.txt', 'w')
file.write('Hello, World!')  # 写入字符串到文件
file.close()

file = open('file.txt', 'w')
lines = ['Line 1\n', 'Line 2\n', 'Line 3\n']
file.writelines(lines)  # 写入多行内容到文件
file.close()

36、CSV文件格式的特点及用途

（1）特点：

1. 1. **简单易读**：CSV 文件使用纯文本形式存储数据，每行表示一个数据记录，字段之间使用逗号进行分隔。它的简洁性使得 CSV 文件易于阅读和编辑，也方便进行数据导入导出。
   2. **扁平结构**：CSV 文件通常采用扁平结构，**不支持复杂的层次关系和嵌套结构**。每行都包含相同数量的字段，每个字段独立存储一个数据值。
   3. **通用性**：CSV 是一种通用的文件格式，几乎所有的电子表格、数据库和数据处理工具都支持 CSV 文件的导入和导出。它可以用于数据交换、数据备份、数据分析等多种用途。
   4. **可读性强**：由于采用纯文本形式，CSV 文件可以在任何文本编辑器中打开和查看。此外，由于字段之间使用逗号分隔，数据也可以轻松地转换为其他格式，如 Excel、JSON 等。

（2）用途：

1. 1. **数据导入导出**：CSV 文件广泛用于将数据从一个应用程序导出到另一个应用程序。它可以作为数据交换的中间格式，方便不同系统之间的数据共享和迁移。
   2. **数据备份**：CSV 文件可以用作简单的数据备份格式。通过将数据导出为 CSV 文件，可以轻松地存储和还原数据，以防止数据丢失或损坏。
   3. **数据分析**：CSV 文件常用于数据分析和统计处理。通过将数据导出为 CSV 文件，可以使用各种数据分析工具和编程语言（如Python）对数据进行处理、分析和可视化。
   4. **数据交换和集成**：由于 CSV 文件的通用性，它被广泛用于数据交换和集成场景。不同系统之间可以通过导入导出 CSV 文件来共享和整合数据。

37、CSV库中文件的读写

import csv

# 读取CSV文件
with open('file.csv', 'r') as file:
    reader = csv.reader(file)
    for row in reader:
        # 对每一行数据进行处理
        print(row)

# 写入CSV文件
data = [
    ['Name', 'Age', 'City'],
    ['John', '25', 'New York'],
    ['Alice', '30', 'London'],
    ['Bob', '35', 'Paris']
]

with open('file.csv', 'w', newline='') as file:
    writer = csv.writer(file)
    writer.writerows(data)

38、JSON文件格式的特点及用途

特点：

1. 1. 可读性强：JSON 使用纯文本形式表示数据，易于阅读和编辑。它采用了类似于JavaScript对象的键值对的结构，使得数据的结构和关系直观清晰。
   2. 独立性：JSON 是一种独立于编程语言的数据格式，几乎所有的编程语言都支持 JSON 的解析和生成。这使得 JSON 可以用于不同语言之间的数据交换和通信。
   3. 支持多种数据类型：JSON 支持多种基本数据类型，如字符串、数字、布尔值、数组、对象以及 null。这使得 JSON 能够灵活地表示各种类型的数据。
   4. 可嵌套性：JSON 对象可以嵌套包含其他 JSON 对象或数组，从而构建复杂的数据结构。这使得 JSON 适合表示层次化和结构化的数据。

用途：

1. 1. 数据交换和通信：JSON 通常用于不同系统之间的数据交换和通信。通过将数据编码为 JSON 格式，可以轻松地在不同平台、不同编程语言之间传输和解析数据。
   2. Web API 数据传输：Web API（应用程序接口）通常使用 JSON 格式来传输数据。客户端应用程序可以通过 HTTP 请求从服务器获取 JSON 数据，并将其解析和展示。
   3. 配置文件：JSON 格式可以用于存储和读取配置文件。应用程序可以将配置选项以 JSON 格式保存到文件中，并在需要时读取配置数据进行初始化。
   4. 数据存储和序列化：JSON 可以用于将数据序列化为文本格式，以便于存储到文件或数据库中。反之，可以将存储的 JSON 数据反序列化为原始数据对象。
   5. 数据传输和存储的可视化：由于 JSON 的可读性，可以直接查看和检查 JSON 数据，以便进行调试、数据分析和可视化。

39、JSON库中的文件读写

import json

# 从JSON文件中读取数据
with open('data.json', 'r') as file:
    data = json.load(file)
    print(data)

# 将数据写入JSON文件
data = {
    'name': 'John',
    'age': 25,
    'city': 'New York'
}

with open('data.json', 'w') as file:
    json.dump(data, file)

40、JSON的序列化和反序列化

# 对象的序列化与反序列化
data = {
    'name': 'John',
    'age': 25,
    'city': 'New York'
}

# 序列化（对象转为JSON字符串）
json_str = json.dumps(data)
print(json_str)

# 反序列化（JSON字符串转为对象）
data = json.loads(json_str)
print(data)

41、CSV文件格式与JSON文件格式的相互之间转换算法

import csv
import json

def csv_to_json(csv_file, json_file):
    # 读取CSV文件
    with open(csv_file, 'r') as file:
        csv_reader = csv.DictReader(file)
        # 将CSV数据转换为字典列表
        data = [row for row in csv_reader]

    # 写入JSON文件
    with open(json_file, 'w') as file:
        # 将字典列表转换为JSON字符串
        json_data = json.dumps(data, indent=4)
        file.write(json_data)

def json_to_csv(json_file, csv_file):
    # 读取JSON文件
    with open(json_file, 'r') as file:
        json_data = json.load(file)

    # 获取字段名称
    field_names = list(json_data[0].keys())

    # 写入CSV文件
    with open(csv_file, 'w', newline='') as file:
        csv_writer = csv.DictWriter(file, fieldnames=field_names)
        csv_writer.writeheader()
        csv_writer.writerows(json_data)

# 示例使用
csv_to_json('data.csv', 'data.json')  # 将CSV文件转换为JSON文件
json_to_csv('data.json', 'data.csv')  # 将JSON文件转换为CSV文件

42、内置函数map的使用

简单点来说，map是在起着一个连接的作用。把函数和参数一前一后放入map，就可以得到参数传入函数后的返回值

• map() 会根据提供的函数对指定序列做映射。

• 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

基本语法：

map(function, iterable)

• function 是一个函数，表示要应用于每个元素的函数。

• iterable 是一个可迭代对象，如列表、元组、集合等。

以下是几个使用 map() 函数的示例：

示例 1: 将列表中的每个元素求平方

numbers = [1, 2, 3, 4, 5]

squared = map(lambda x: x**2, numbers)
# 或者使用定义的函数
# def square(x):
#     return x**2
# squared = map(square, numbers)

print(list(squared))  # 输出: [1, 4, 9, 16, 25]

示例 2: 将字符串列表中的每个字符串转换为大写

words = ['apple', 'banana', 'cherry']

uppercased = map(str.upper, words)

print(list(uppercased))  # 输出: ['APPLE', 'BANANA', 'CHERRY']

示例 3: 将两个列表中的元素一一对应相加

nums1 = [1, 2, 3]
nums2 = [4, 5, 6]

result = map(lambda x, y: x + y, nums1, nums2)

print(list(result))  # 输出: [5, 7, 9]

43、扩展库安装的操作命令:pip install、pip list

pip install 库名  # 安装一个库
pip install 库名1 库名2 库名3   # pip安装多个库
pip list  # 查看已安装库

44、面向对象概念

• 类、对象

• 类方法、静态方法、实例方法及使用

  • 静态方法: 用 @staticmethod 装饰的不带 self 参数的方法叫做静态方法，类的静态方法可以没有参数，可以直接使用类名调用。

  • 普通方法: 默认有个self参数，且只能被对象调用。

  • 类方法: 默认有个 cls 参数，可以被类和对象调用，需要加上 @classmethod 装饰器。

• 动态增加成员属性、成员方法

• 私有成员及访问

  • 变量名由两道下划线开头表示私有属性

• 类中的特殊方法及含义

• 类的继承（包括多继承）

  • 在类名后面加上小括号，加上父类的类名

• 同名方法的引用次序

  • 优先调用子类的方法

• 构造函数定义

• 父类构造函数的调用（包括多个父类）

class Person:
    def __init__(self,name,age,email):
        self.__name = name   # 变量名由两道下划线开头表示私有属性
        self.age = age
        self.email = email

    # 类方法
    @classmethod
    def run(cls):
        print("人都会跑步")

    # 静态方法
    @staticmethod
    def sleep():
        print("睡觉了，跑不动了")

    # 实例方法
    def study(self,hour):
        print("今天我要学{}小时".format(hour))

# 动态添加成员属性成员方法
def calcu(a,b):
    return a+b
person = Person('张三',20,"[email protected]")
person.calcu = calcu   # 动态添加方法
person.score = 90  # 动态添加属性

# 类继承
class Doctor(Person):
    def __init__(self, name, age, email,project):
        super().__init__(name, age, email)
        self.project = project

    def sleep(self):
        print("继续睡！")

45、python类的特殊方法及其含义

1. __init__(self, ...)：

   • 初始化方法，也称为构造函数。

   • 在创建对象时自动调用，用于初始化对象的属性。

2. __str__(self)：

   • 返回对象的字符串表示。

   • 当使用 str(object) 或 print(object) 时，自动调用该方法。

   • 通常用于返回对象的可读性好的字符串形式。

3. __repr__(self)：

   • 返回对象的字符串表示，通常是对象的准确表示。

   • 当使用 repr(object) 时，自动调用该方法。

   • 通常用于调试和开发目的。

4. __len__(self)：

   • 返回对象的长度。

   • 当使用 len(object) 时，自动调用该方法。

5. __getitem__(self, key)：

   • 获取对象的指定键（key）的值。

   • 当使用索引操作符 object[key] 时，自动调用该方法。

6. __setitem__(self, key, value)：

   • 设置对象的指定键（key）的值。

   • 当使用索引操作符 object[key] = value 时，自动调用该方法。

7. __delitem__(self, key)：

   • 删除对象的指定键（key）的值。

   • 当使用 del object[key] 时，自动调用该方法。

8. __eq__(self, other)：

   • 判断对象是否相等。

   • 当使用 == 运算符进行比较时，自动调用该方法。

9. __lt__(self, other)：

   • 判断对象是否小于另一个对象。

   • 当使用 < 运算符进行比较时，自动调用该方法。

10. __gt__(self, other)：

    • 判断对象是否大于另一个对象。

    • 当使用 > 运算符进行比较时，自动调用该方法。