python学习记录

一、数据类型

1.列表

列表切片赋值

list1 = [0, 1, 2, 3, 4, 5]
list1[1:4] = ['a','b','c']

　　

列表合并

>>> a = [1,2,3]
>>> a += [4,5,6]
>>> a
[1, 2, 3, 4, 5, 6]

列表的方法

append、insert、pop、remove、reverse

速记: append、insert、remove、reverse四个函数返回值为None， pop返回值为删除的元素值。remove只会删除第一个匹配元素

a = [1, 2, 3.14, 'byhy.net']  

# 取出索引为3 的元素，也就是第4个元素
poped = a.pop(3)

# 取出后，a列表对象内容就变成了 [ 1, 2, 3.14]
print(a)


# 而取出的元素赋值给变量poped， poped的内容就是 'byhy.net'  
print(poped)

　　可以使用 sort 方法对列表进行排序。

调用sort 方法，的列表中的元素通常都是是 数字 或者 字符串。如下

students = ['Alex','Tom','Jerry','Michale','Alex']
students.sort()
print(f'after sort: {students}')

numbers = [7,3,8,2,9]
numbers.sort()
print(f'after sort: {numbers}')

 列表遍历

enumrate 获取每个元素，还需要得到每个元素在列表元组里面的索引

studentAges = ['小王:17', '小赵:16', '小李:17', '小孙:16', '小徐:18']

# enumerate (studentAges) 每次迭代返回 一个元组
# 里面有两个元素，依次是 元素的索引和元素本身 
for idx, student in enumerate(studentAges):
    if int(student.split(':')[-1]) > 17:
        print(idx)

20240417

列表推导式(有两种)

[x for x in data if condition]   #if起到条件判断的作用

[exp1 if condition else exp2 for x in data] # if else 起到赋值的作用

 

　

2.元组

如果元组中只有一个元素，必须要在后面加上逗号，像这样

a = (1, )

　　定义元组还可以去掉圆括号，像这样

a = 1, 2, 3.14, 'hello'

　　如果元组中只有一个元素，必须要在后面加上逗号，像这样

a = 1,

多个变量同时赋值

x,y = (1,2)   # x 的值为 1， y 的值为 2
print(x,y)   

name, age = ['李逵', 33] # name 的值为 '李逵'， age 的值为 33
print(name,age)

连写比较表达式

num = 3
2 < num <= 5

  等同于

num > 2 and num <=5　

3.字典

字典元素的 键 必须是 可进行哈希值计算 的对象， 通常是 数字 或者 字符串

删除: 

members = {
    'account1'  : 13 ,
    'account2'  : 12 
}

val = members.pop('account1')
print(members)
print(val)

　　也可以使用 del 关键字来删除一个元素，比如

del members['account1']

　　遍历:

members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}

for account,level in members.items():
    print (f'account:{account}, level:{level}')

 获取键列表: members.keys()

 获取值列表: members.values()

清空字典

members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}

members.clear()

print(members)

　　字典合并

members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}

another =  {
    'account4'  : 13 ,
    'account5'  : 12 ,
}

members.update(another)

print(members)

　　字典元素个数:

members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}


print(len(members)) # 结果为3，表示字典中有3个元素

　

二、常用函数

速记: split切割字符串为列表，join连接列表为字符串

split 是我们常用的方法，经常用来从字符串中 截取 出我们想要的信息，将字符串 切割为多个 字符串，作为元素存入一个列表，并返回这个列表

splitlines 方法也比较常用，就是把字符串 按换行符 进行切割。用于文件读取

join正好与split相反，

split 是将字符串， 以 某字符串 为界， 切割 成多个字符串， 存入列表

join 是将列表中的字符串元素 以某字符串为连接符， 连接 为一个字符串

strip方法可以将 字符串前面和后面的空格删除，但是不会删除字符串中间的空格

lstrip方法 将 字符串前面 (左边) 的空格删除，但是不会删除字符串中间和右边的空格

rstrip方法 将 字符串后面 (右边) 的空格删除，但是不会删除字符串中间和左边的空格

replace 也是常用的方法，用来 替换 字符串里面 所有指定的 子字符串 为另一个 字符串

startswith 方法检查字符串是否以参数指定的字符串 开头，如果是，返回True，否则返回False

endswith 方法检查字符串是否以指定的字符串 结尾，如果是，返回True，否则返回False

isdigit 方法检查字符串是否全部由数字构成，如果是，返回True，否则返回False

ljust 方法将字符串进行左对齐, str.ljust(width, fillchar)

rjust 方法将字符串进行右对齐 

要得到一个字符串的 倒序字符串，只需要使用切片操作 [::-1],也可用str.reverse()

6.格式化字符串

f-string格式（Python解释器是3.6 以后的版本才支持）

指定宽度

salary = 10000
print(f'{salary:10}')

　　f'{salary:10}' 就指定了 宽度为10 个字符， 如果填入的字符串不足10个字符，就在前面加上空格,

对齐:  对于数字对象来说，缺省为 右边对齐，而字符串缺省为 左边对齐

如果我们想指定左右对齐，可以在括号里使用 < > 符号，箭头朝左就是左对齐，箭头朝右就是右对齐。

小数点保留：如果我们想指定小数点后保留几位，可以像这样 {salary:<8.1f} 后面的.1f就表示小数点后面保留1位

不足补数字: 如果我们想在不足指定宽度的时候不是补空格，而是补数字0，可以像这样 {salary:08}

上面的例子是对 数字 的不足补零，如果要对 字符串 不足补零，就应该 使用符号 < 或者 > 同时指定左右对齐方式。

16进制

# 用 x 表示格式化为16进制，并采用小写格式
f'数字65535的16进制表示为：{65535:x}'  


# 用 X 表示格式化为16进制，并采用大写格式
f'数字65535的16进制表示为：{65535:X}'

　　采用 f-string 方式格式化的 字符串内容本身就有 { 或者 } 符号，一定要 双写 进行转义，否则会被当成是 格式化占位符。

7.循环

循环n次

for n in range(100):

for n in range(50,101,5): 如果我们想打印出从50, 55, 60, 65... 这样每次增加5， 直到 100

三、读写文件

10.文件读写

open(
    file, 
    mode='r', 
    buffering=-1, 
    encoding=None, 
    errors=None, 
    newline=None, 
    closefd=True, 
    opener=None
    )

　　"+" 代表可读可写

后面调用write写入字符串到文件中，open函数会使用指定encoding编码为字节串；

后面调用read从文件中读取内容，open函数会使用指定encoding解码为字符串对象

如果调用的时候没有传入encoding参数值，open函数会使用系统缺省字符编码方式。 比如在中文的Windows系统上，就是使用cp936（就是gbk编码）。code page

 

读取read函数,最好加上读取的大小，适用于小文件读取。read(3)

读取的时候有文本指针的说法

按行读取函数，都返回列表 : readlines（包含换行符）     splitlines(不包含换行符)

seek函数  seek(offset[, whence])

其中，offset表示相对于whence指定位置的偏移量（字节数）。whence参数可选，默认为0，其取值和意义如下：

• 0：表示文件开头，offset必须为正数（或零，表示文件开始位置）。

• 1：表示当前位置，offset可为正数（向后移动）或负数（向前移动）。

• 2：表示文件结尾，offset必须为负数（或零，表示文件结尾位置）

 

二进制文件读取:

注意: 读写文件底层操作读写的 都是字节,   只涉及到字节不会存在编解码，涉及到字节和字符就会有编解码

# mode参数指定为rb 就是用二进制读的方式打开文件
f = open('tmp.txt','rb')
content = f.read()   
f.close()  

# 由于是 二进制方式打开，所以得到的content是 字节串对象 bytes
# 内容为 b'\xe7\x99\xbd\xe6\x9c\x88\xe9\xbb\x91\xe7\xbe\xbd'
print(content) 

# 该对象的长度是字节串里面的字节个数，就是12，每3个字节对应一个汉字的utf8编码
print(len(content))

# mode参数指定为 wb 就是用二进制写的方式打开文件
f = open('tmp.txt','wb')

content = '白月黑羽祝大家好运连连'
# 二进制打开的文件， 写入的参数必须是bytes类型，
# 字符串对象需要调用encode进行相应的编码为bytes类型
f.write(content.encode('utf8'))

f.close()

　　写入缓冲

等缓冲区的内容堆满之后，或者程序调用close 关闭文件对象的时候，再写入到文件中。 立即写入，可以使用文件对象的 flush方法

11.模块调用(模块就是一个文件)

import save
from save import savetofile
import aa, bb, cc
from aa import func1,var1,func2,var2 #我们要从1个模块里导入多个标识符，可以这样
from aa import *                               #使用*代表所有可导入的标识符
from save import savetofile
from save2 import savetofile as savetofile2 # 重命名防止重名

　　将模块放入包   Python 3.3 以前的版本，包目录里面需要有一个名字为 __init__.py

                                Python 3.3 以后版本的解释器， 如果目录只是用来存放模块文件，就不需要一个空的 __init__.py 了。

　　　　　　　　　　但是 __init__.py 可以作为包的初始化文件，里面放入一些初始化代码，有独特的作用。

 

标准库

import sys
sys.exit(0)

import datetime

# 返回这样的格式 '20160423'
datetime.date.today().strftime("%Y%m%d") 

# 返回这样的格式 '20160423 19:37:36'
datetime.datetime.now().strftime("%Y%m%d %H:%M:%S")

　四、 类

创建实例对象-->调用__init__方法

类的静态方法要在方法定义 上面加上 @staticmethod 的修饰。

通常类的实例方法，都是要 访问类的实例属性的。 包括： 创建、修改、删除 类的实例属性。

因为 实例方法 就是要操作 实例独有的属性，否则不操作任何实例属性的话，就应该定义为 类方法。 静态方法是不能访问实例属性的。

注意: 如果你的实例属性名称 和 静态属性 重复了 ，通过类实例访问该属性，访问的是实例属性。通过类名访问该属性，访问的是类属性。

 

• 静态属性‌：在类定义时确定，不能在运行时添加或删除，通常用于不需要访问类或实例属性的方法。@staticmethod，不用实例化即可调用
• ‌动态属性‌：可以在运行时添加、修改或删除，提供了更高的灵活性和动态性
• 静态字段可以用实例或者类进行访问，动态字段只能使用实例进行访问(静态字段在代码加载时就已经创建好了，动态字段在对象实例化时才创建)

 

• 静态方法就是在普通方法面前加@staticmethod,同时去掉self形式参数，其他参数可以任意多个或0个。如果一个方法不使用对象（即不使用self）或不需要用对象的数据，建议创建成静态方法；
• 类方法：在普通方法前面加装饰器@classmethod，且方法中需要至少有cls形式参数，cls代指类名。类方法比静态方法多一个特征或功能，自动传递类名。用来创建对象时非常有用；
• 静态方法、类方法可以由类或者对象来调用，而普通方法只能由对象来调用；

 

• 类方法可以用于根据不同的参数创建不同类型的对象

class Shape:
    def __init__(self, color):
        self.color = color
    
    @classmethod
    def create(cls, shape_type, color):
        if shape_type == "circle":
            return Circle(color)
        elif shape_type == "rectangle":
            return Rectangle(color)
    
class Circle(Shape):
    def __init__(self, color):
        super().__init__(color)
        self.type = "circle"
    
class Rectangle(Shape):
    def __init__(self, color):
        super().__init__(color)
        self.type = "rectangle"

circle = Shape.create("circle", "red")
rectangle = Shape.create("rectangle", "blue")

 

修改类级别的属性

class Counter:
count = 0

@classmethod
def increment(cls):
cls.count += 1

@classmethod
def decrement(cls):
cls.count -= 1

Counter.increment()
Counter.increment()
Counter.decrement()
print(Counter.count) # 输出: 1

提供替代构造方法
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    @classmethod
    def from_file(cls, filename):
        with open(filename, "r") as f:
            data = f.read().split(",")
            name = data[0]
            age = int(data[1])
            return cls(name, age)

person = Person.from_file("data.txt")

 

__init__和__new__的区别： new用于创建实例，init用于实例的初始化配置，先new后init。

 

魔术方法（自动执行的方法）:

在Python中，所有以双下划线__包起来的方法，统称为Magic Method（魔术方法），它是一种特殊的方法，普通方法需要调用，而魔术方法不需要调用就可以自动执行。
魔术方法在类或者对象的某些事件触发后会自动执行，让类具有神奇的“魔力”。如果希望根据自己的程序定制自己特殊功能的类，那么就需要对这些方法进行重写。

 

类之间的关系（继承和组合）

子类会自动拥有父类的一切属性和方法

子类调用父类的方法

def __init__(self,color,engineSN,weight):
    # 同样是调用父类的初始化方法
    super().__init__(color, engineSN)
    self.weight = weight 
    self.oilweight = 0

 

14.异常

匹配所有异常

try:
    100/0
except Exception as e:
    print('未知异常:', e)

　　

打印异常的信息

import traceback

try:
    100/0
except :
    print(traceback.format_exc())

 

15.变量

函数内部使用全局变量global

可变参数

def  printAge(*students) :
    for  student in students:
        print( f'学生：{student} , 年龄 {studentInfo[student]}')

这种前面加一个星号的参数，称之为可变参数

 

在调用该函数的时候，Python解释器会创建一个 tuple 赋值给这个参数变量。并且会把 传入的数据对象 放到这个tuple对象里面。

 

printAge(*onebatch)

这里是在调用函数的时候,传入参数前面加上星号，是参数展开

 

关键字可变参数(参数个数不固定)

def addStudents(table,**students):
    print(type(students))
    for name,age in students.items():
        table[name] = age

table1 = {}
table2 = {}
addStudents(table1, 李白=20, 杜甫=24)
addStudents(table2, Jodan=45, James=32, onil=40)
print(table1)
print('----------------')
print(table2)

　　

onebatch = {'李白': 20, '杜甫': 24}
addStudents(table1, **onebatch)

这种前面加2个星号的参数，称之为关键字可变参数，

在调用该函数的时候，Python解释器会创建一个 dict （字典） 赋值给这个参数变量。并且会把 传入的数据对象 分别放到这个dict 对象里面。传入的参数对象，必须是像 name=value这种 带参数名和参数值的， 放到dict对象时，参数名是字典元素的key，参数值是字典元素的value。

五、常用库

1.datetime和time的区别(datetime是time的加强版)

time模块提供如time()获取当前时间戳、‌sleep()使程序暂停等功能，‌适合处理与时间戳相关的操作，‌如计算时间间隔、‌时间格式化等

datetime模块提供更高级的时间操作方法，‌如日期时间的加减运算，‌适合处理日期和时间相关的操作，‌如日期计算、‌时区处理等。

‌如果需要处理底层的时间操作或与时间戳相关的计算，‌可以选择time模块；‌如果需要进行日期时间的格式化、‌加减运算或处理更复杂的日期时间操作，‌则datetime模块是更合适的选择

time转datetime,使用函数 fromtimestamp()

datetime格式化输出为字符串,使用函数 datetime.datetime.strftime("%Y-%m-%d,%H:%M:%S")

五、正则表达式

re模块

re.match函数