Python基础语法（二）

时间：2021-04-30 14:54:22

  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

    相关文章