大纲
1、汉字编码
2、浅拷贝与深拷贝
3、函数
4、return
5、函数的基本参数
6、format
7、三元运算（三目运算）
8、python的内置函数
abs() all() any() bool() bin() oct() hex()
bytes()
callable()
ord() chr()
compile() exec() eval()
dir() help()
filter()
9、open函数
汉字编码
汉字的字节：
utf-8 一个汉字：三个字节
gbk 一个汉字：二个字节
一个字节等于八位；1byte=8bits
对于字典、元祖、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同的。关于这个深浅拷贝为了方便自己，所以复制了老师的
浅拷贝与深拷贝
1、赋值
赋值，只是创建一个变量，该变量指向原来内存地址，如：
|
1
2
3
|
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]} n2 = n1 |
2、浅拷贝
浅拷贝，在内存中只额外创建第一层数据
|
1
2
3
4
5
|
import copy n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]} n3 = copy.copy(n1) |
3、深拷贝
深拷贝，在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化）
|
1
2
3
4
5
|
import copy n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]} n4 = copy.deepcopy(n1) |
函数
函数分为自定义函数，和python的内置函数
定义：
函数是指将一组语句的集合通过一个名字（函数名）封装起来，想要执行这个函数，只需要调用其函数名即可
语法定义：
def hello():#hello是函数名，def关键字用于创建函数 print("hello world...") hello()#调用函数
函数的执行过程：
1、def关键字，创建函数
2、函数名
3、()
4、函数体（函数体默认是不执行的，当我调用时执行）
5、返回值
函数的特性：
1、减少重复代码
2、是程序变的可扩展
3、是程序变得已维护
return返回值的使用：
def ret(): print("hello world") return "success"#在函数中，一旦执行了return后，函数执行过程立即终止，返回值将会赋给我们定义的函数 print(123)#123是不会执行的 r = ret() print(r) hello world success
return默认的返回值：
def ret(): print(123) r = ret() print(r) 123 None#python默认的返回值为none
函数的基本参数：
1、基本参数 == 形参、实参
2、默认参数（必须放置参数的最后面）
3、指定参数 == 相当于a="b"、b="a"
4、动态参数：
* == 相当于一个元组
** == 相当于一个字典
形参、实参定义方法：
def parameter(p1, p2): # 在定义时被称为形参，相当于他是一个变量 print("name:", p1, "age:", p2) return "..." parameter("smelond", 16) # 在调用时我输入的参数被称为实参，大概就是他是一个实际的值，反正我是这样理解的 name: smelond age: 16
默认参数：
def parameter(p1, p2="16"): # 默认参数必须放置在形参列表的最后面 print("name:", p1, "age:", p2) return "..." parameter("smelond") #在调用过程中，如果我不传参进去他就会输出默认的值 name: smelond age: 16
指定参数：
def parameter(p1, p2): # 形参的常规写法 print("name:", p1, "age:", p2) return "..." parameter(p2 = "smelond", p1 = 16) #在调用过程时，我们只需要指定形参名即可 name: 16 age: smelond
动态参数
* 接收N个实际参数（元组）:
def n_p(*args):#只要在前面加上一个*，他可以接受N个实际参数 print(args, type(args)) n_p(11, 22, 33) (11, 22, 33) <class 'tuple'>#输出时会把他们转换为元组
def n_p(*args): print(args, type(args)) li = [11, 22, 33, "smelond"] # 给了一个列表 n_p(li, "44") ([11, 22, 33, 'smelond'], '44') <class 'tuple'>#就算是列表他也只当了一个元素，可以看到输出时在元组里面有一个列表
def n_p(*args): print(args, type(args)) li = [11, 22, 33, "smelond"] # 给了一个列表 n_p(*li) # 如果在实参前面加上*，在输出时他会像for循环一样，把每一个列表循环到元组里面，从而有了多个元素 li = "smelond" # 字符串也一样 n_p(*li) (11, 22, 33, 'smelond') <class 'tuple'> ('s', 'm', 'e', 'l', 'o', 'n', 'd') <class 'tuple'>
**接收N个实际参数（字典）：
def d_p(**kwargs): # **他接收的是一个字典 print(kwargs) d_p(k1="v1", k2="v2")#以key value的方式传参 {'k1': 'v1', 'k2': 'v2'}
def d_p(**kwargs): # **他接收的是一个字典 print(kwargs) dic = {"k1": "v1", "k2": "v2"}#定义一个字典 d_p(k1=dic) # 因为在这个地方v为一个字典，所以输出时会嵌套一个字典 {'k1': {'k1': 'v1', 'k2': 'v2'}}
万能参数：
def d_p(*args, **kwargs): # 接收一个元组和一个字典 print(args) print(kwargs) d_p(11, 22, 33, k1="v1", k2="v2") # 将他俩同时传入 (11, 22, 33) {'k1': 'v1', 'k2': 'v2'}
利用动态参数实现format功能：
# 一个*的使用方法（列表）
s1 = "i am {0}, age {1}".format("smelond", 16) # format会将smelond副歌0,16赋给1，
print(s1)
li = ["smelond", 16]
s2 = "i am {0}, age {1}".format(*li) # 因为是列表，所以加上*号输出效果是一样的
print(s2)
# 两个*的使用方法（字典）
s3 = "i am {name}, age {age}".format(name="smelond", age=16) # 如果前面括号里面为什么，我们的key值就得为什么
print(s3)
dic = {"name": "smelond", "age": 16}
s4 = "i am {name}, age {age}".format(**dic) # 在这个地方得加上**因为他是一个字典
print(s4)
i am smelond, age 16
i am smelond, age 16
i am smelond, age 16
i am smelond, age 16
三元运算（三目运算）表达式：
# 以下是if_else的常规写法
if 1 == 1:
name = "smelond"
else:
print("age")
# 三元运算就可以写简单的if_else
name = "smelond" if 1 == 1 else "age" # 意思是说，如果1 == 1，那么将"smelond"赋给变量name，否者将age赋给name
print(name)
smelond
lambda表达式：
# lambda 写一些简单的函数可以用lambda表达式
def f1(a1):
return a1 + 100
r1 = f1(10)
print(r1) # def的简单常规写法
# 如果用lambda表达式：
f2 = lambda a1, a2=10: a1 + a2 + 100 # 最前面的f2代表函数名，冒号前面的是形参，可以看到在这个里面也可以个形参加默认值，冒号后面的就是简单的运算
r2 = f2(10)
print(r2)
110
120
python的一些内置函数：
# 内置函数一 # abs() 返回绝对值 n = abs(-1) print(n) # 1 # all() # any() # 0,None,"",[],{},() == 全部都为False # all()所有为真，才为真 n = all([1, 2, 3, 4, None]) print(n) # # any()只要有一个为真，就为真 n = any([1, [], []]) print(n) # bool值，返回真假 print(bool(0)) print(bool(True)) # ascii() #自动执行对象的__repr__方法 # bin() 接收一个十进制，会把十进制转换为二进制(0b) print(bin(5)) # oct() 接收一个十进制，会把十进制转换为八进制(0o) print(oct(9)) # hex() 接收一个十进制，会把十进制转换为十六进制(0x) print(hex(15)) 1 False True False True 0b101 0o11 0xf
# 内置函数二 # 字符串转换为字节类型 # bytes(只要转换为字符串，按照什么编码),字符串只要想转换字节，就要用bytes n = bytes("编码", encoding="utf-8") print(n) n = bytes("编码", encoding="gbk") print(n) # 将字节转换为字符串 st = str(b'xe7xbcx96xe7xa0x81', encoding="utf-8") # 这段字节是有上面的字符串转换的 print(st) b'xe7xbcx96xe7xa0x81' b'xb1xe0xc2xeb' 编码
三
# callable()#检查函数是否能被调用，返回True、False def f1(): pass # f1()#能被调用 f2 = 123 # f2()# 这个不能被调用 print(callable(f1)) # 能被调用 print(callable(f2)) # 不能被调用 # 查看对应的ascii码 # ord()把ASCII转换成数字 # chr()则相反，把数字转换成ASCII r = chr(65) print(r) # A n = ord("a") print(n) # 97
# compile()#可以将字符串编译为python的代码 # 编译：single，eval，exec s = "print(123)" r = compile(s, "<string>", "exec") # 将字符串编译成python代码 print(r) # 执行 # exec()# 执行python代码，接收：代码或者字符串 ，只执行，没有返回值 exec(r) # 执行 # eval()#执行表达式，并且获取结果（有返回值） s = "8*8" ret = eval(s) print(ret)
# dir()#快速的查看一个对象为你提供了哪些功能 print(dir(list)) # help()#查看帮助信息 # help(list) # 共：97条数据，每页显示10条，需要多少页 r = divmod(100, 10) print(r) n1, n2 = divmod(100, 10) # 同时赋给两个变量 print(n1, n2) # 对象是类的实例 s = [11, 22, 33] # 用于判断，对象是否是某个类的实例 r = isinstance(s, list) # 前面是对象，后面是类 print(r)
# filter(函数，可迭代的对象)#返回True或False，用于过滤 def f2(a): if a > 22: return True li = [11, 22, 33, 44, 55] # filter内部，循环第二个参数 # result = [] # for item in 第二个参数: # r = 第一个参数(item) # if r : # result(item) # return result # filter,循环循环第二个参数，让每一个循环元素执行 函数，如果函数的返回值是True，表示元素合法 ret = filter(f2, li) print(list(ret)) # lambda版本的filter li = [11, 22, 33, 44, 55] ret = filter(lambda a: a > 33, li)#直接在放函数的位置进行筛选 print(list(ret))
open函数：
# 1、打开文件 # f = open("db", "r") # 只读 # f = open("db", "w") # 只写，写之前会把文件清空 # f = open("db", "x") # 文件存在，报错；不存在，创建并写内容 # f = open("db", "a") # 追加 # # f = open("db", "rb") # 以字节类型读，只要加上b，都是二进制，二进制表现在代码里面就是字节类型 # date = f.read() # print(date, type(date)) # # f = open("db", "ab") # f.write(bytes("test", encoding="utf-8")) # ab以字节方式写入文件，记得加上bytes以utf-8转换 # f.close() # r+ 用的最多 f = open("db", "r+", encoding="utf-8") # 如果打开模式无b，则read，按照字符读取 date = f.read(12) print(date) print(f.tell()) # tell获取当前指针的位置(永远是字节) f.seek(1) # r+既可读，又可写，如果这里面加入一个seek()方法，调整当前指针的位置(字节) f.write("777") # 写的时候，当前指针位置开始向后覆盖 f.close() # 2、操作文件 # read() #无参数，读全部；有参数， # b,按字节 # 无b，按字符 # tell() 获取当前指针位置(字节) # seek() 指针跳转到指定位置(字节) # write() 写数据，有b：写字节；无b：写字符； # close() 关闭文件，如果打卡了必须调用此方法 # fileno() 文件描述符 # flush() 强制刷新 # readable() 判断是否可读，返回True或False # readline() 仅读取一行 # truncate() 截断，指针位后的清空 # for循环文件对象 f = open(xxx) # for line in f: # print(line) # 通过源码查看功能 # 2、关闭文件 # f.close() with open("xb") as f: # with打开文件操作完成之后，会自动关闭文件 pass with open("db1") as f1, open("db2") as f2: # 可以同时打开多个文件 pass # 在代码块里面两个文件都打开，代码块执行完毕之后，两个文件都关闭
打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。 打开文件的模式有： r ，只读模式【默认】 w，只写模式【不可读；不存在则创建；存在则清空内容；】 x， 只写模式【不可读；不存在则创建，存在则报错】 a， 追加模式【可读； 不存在则创建；存在则只追加内容；】 "+" 表示可以同时读写某个文件 r+， 读写【可读，可写】 w+，写读【可读，可写】 x+ ，写读【可读，可写】 a+， 写读【可读，可写】 "b"表示以字节的方式操作 rb 或 r+b wb 或 w+b xb 或 w+b ab 或 a+b 注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型