Python基础语法（二）

1. 类中的方法定义前如果有 @staticmethod 则此方法通过类名调用，如：dict.fromkeys() ； 如果没有，则此方法通过对象调用

2. 三元运算

   1. name=值1 if 条件 else 值2      如果条件成立，则name=值1  否则  name=值2

3. str ， 一次性创建，不能被修改，只要修改，就会在内存中再创建。 对

   1. 于 数字 和 字符串 而言，赋值、浅拷贝和深拷贝无意义，因为在Python中经优化后其永远指向同一个内存地址。

   2. 浅拷贝，对于有多层结构的对象，浅拷贝只拷贝第一层，然后拷贝的第一层的指向下级的地址是不变的

   3. 深拷贝，对于有多层结构的对象，深拷贝是把层级结构都拷贝了，只有最后一级的数字和文本不拷贝

   4. id(对象)方法，可以查看指定对象的内存地址

   5. 浅拷贝

import copy

n1 = {“k1”:”Li”,”k2”:123,”k3”:[“alex”,456]}

n3 = copy.copy(n1)

1. 深拷贝

import copy

n1 = {“k1”:”Li”,”k2”:123,”k3”:[“alex”,456]}

n4 = deepcopy.copy(n1)

1. 函数

   1. 定义：

def 函数名（[参数]）:

……

[return …]

1. 如果函数中没有return，则函数会返回None

2. 动态参数

   1. 参数名称以*为前缀，这个参数的类型会是一个元组，如： def fun1(*a)

   2. 参数名称以**为前缀，参数须是一个字典类型，如： fun1(k1=123, k2=345,k3=567)

   3. 参数中同时有*为前缀 和 **为前缀的参数时，必须以*为前缀在前，**为前缀的在后，如： def fun1(*args, **kwargs)  或  def fun2(a, *args, **kwargs)

   4. 当形参以*为前缀，实参为列表如：li = [11,22,33,44,55] 时，

      1. fun1(li)   函数接收到的参数值是：([11, 22, 33, 44, 55],)

      2. fun1(*li)  函数接收到的参数值是：(11, 22, 33, 44, 55)

   5. 当形参为**为前缀，实参为字典如：dic = {“k1”:123}

      1. fun1(dic)  这样调用时会报错，要求须是 k1=123格式的传参

      2. fun1(**dic)  这样就可以正常把字典中的key和value都作为参数传过去

1. lambda 表达式

   1. 无参数

def fun1():
     return 123

 fun2 = lambda : 123

 f1 = fun1()
 f2 = fun2()

print(f1)
print(f2)

1. 有参数

def fun1(a1, a2):
     return a1+a2

 fun2 = lambda a1, a2 : a1+a2

 f1 = fun1(8,9)
 f2 = fun2(18,19)

print(f1)
print(f2)

1. Python 内置函数

   1. abs()函数，取绝对值

   2. all()函数，循环参数，如果每个元素都为真，那么all的返回值为真

   3. any()函数，只要有一个元素为真，则返回真

   4. bool()函数，把元素转换为布尔类型，0、None、空字符串、空列表、空元组、空字典 都会转为False，其他都会转为True

   5. ascii()函数，在对象的类中找 __repr__，获取其返回值

   6. bin()函数，二进制

   7. oct()函数，八进制

   8. int()函数，十进制，base参数是指把几进制转换为十进制

   9. hex()函数，十六进制

   10. bytes()函数，字节转字符串，如：bytes(“xxxxx”,encoding=”utf-8”)

   11. bytearray()函数，字节列表

   12. chr()函数，返回数字对应的ascii字符

   13. ord()函数，返回字符对应的ascii码数字

   14. callable()函数，判断函数是否可以调用，如果可以，返回true

   15. filter(函数，可迭代对象)，函数参数可接收一个参数并返回true或false，filter返回经函数判断为true的迭代项

   16. map(函数，可迭代对象)，对可迭代对象元素都调用给定函数并返回结果

   17. eval()函数，计算字符串中的运算

   18. exec()函数，执行字符串中的程序

   19. globals()函数，获取所有全局变量

   20. locals()函数，获取所有局部变量

   21. isinstance(变量，类型)，判断某个对象是否是某个类创建的

   22. iter(可迭代对象)，迭代器，可创建并返回一个迭代的对象，对返回的这个对象执行next(迭代器)，可获取它的下一个元素

   23. max(列表)函数，获取列表的最大值

   24. min(列表)函数，获取列表的最小值

   25. sum(列表)函数，获取列表的所有元素的和

   26. pow()函数，求幂的，如：pow(2,10)

   27. reversed(可迭代对象)，对列表或字典进行反转

   28. round()函数，四舍五入

   29. zip()函数，可接收多个可迭代对象，按元素顺序合并成

2. 文件操作

   1. open(文件名，模式，编码)

   2. 文件打开的模式有：

      1. r，只读模式【默认】

      2. w，只写模式【不可读，不存在则创建，存在测清空内容】

      3. x，只写模式【不可读，不存在则创建，存在则报错】

      4. a，追加模式【不可读，不存在则创建，存在则追加内容】

   3. “+”表示同时读写某个文件

      1. r+，读写

         1. 指针为0，起始位置；w，末尾追加，指针移动到最后

      2. w+，写读

         1. 先清空所有内容，从开始向后读，之后写的才能读，写，指针到最后

      3. x+，写读

      4. a+，写读

         1. 打开的同时，指针已经到最后

   4. “b”表示以字节的方式操作

      1. rb 或 r+b

      2. wb 或 w+b

      3. xb 或 x+b

      4. ab 或 a+b

   5. 读

f = open("ha.log")
 data = f.read()
 f.close()
print(data)

f = open("ha.log","r", encoding="utf-8")
 data = f.read()
 f.close()
 print(data)

1. 常用方法

   1. close()，关闭文件

   2. fileno()，文件描述符

   3. flush()，刷新文件内容到缓存区

   4. next()，获取下一行数据，不存在，则报错

   5. read()，读取指定字节数据

   6. readline()，仅读取一行数据

   7. readlines()，读取所有数据，并根据换行保存值列表

   8. seek()，指定文件中指针位置

   9. tell()，获取当前指针位置

   10. truncate()，截取数据，仅保留指针之前数据

   11. write()，写内容

f = open("ha.log",'r',encoding="utf-8")
for line in f:
     print(line)
 f.close()

1. for line in f  可以逐行读取文件所有内容

2. 关闭文件

with open("ha.log","r",encoding="utf-8") as f:
     data = f.read()
 print(data)

1. 同时打开两个文件，可用于文件复制等

with open("ha.log","r",encoding="utf-8") as f1, open("ha2.log",'w',encoding="utf-8") as f2:
     for line in f1:
         f2.write(line)

1. 装饰器

   1. 根据 开放封闭原则 ，对类或函数体内的程序不要做改动，如果要做改动，尽量中类或函数体的外部，以免多次修改破坏原来的结构

def outer(func):   ---装饰器
     def inner():
         print("Hello")
         print("Hello")
         print("Hello")
         r = func()  ---执行原函数
         print("End")
         print("End")
         print("End")
         return r  ---return原函数的执行结果
     return inner

 @outer     ---给其下的方法调用自定义的装饰器；执行outer函数，并且将其下面的函数名作为参数；将outer的返回值重新赋值给fun1=outer的返回值；新fun1函数=inner
def fun1():
     print("F1")

def fun2():
     print("F2")

def fun100():
     print("F100")

 fun1()  

-------装饰前输出结果-------

F1

-------装饰后输出结果-------

Hello

Hello

Hello

F1

End

End

End