一天入门python基础小笔记

一天入门python基础小笔记

1 print函数（如何hello world）

1.1 输出数字

（‘#’注释后为print输出结果,下同。）

print(123)  # 123

1.2 输出字符串

# 单引号’ ‘ 或者 双引号” “
print('sad')  # sad

print("sad")  # sad
# 三单引号‘’‘ ’‘’ 或者 三双引号“”“ ”“”:可以分布在多行显示
print('''sad
sad''')  # sad
         # sad
print("""sad
sad""")  # sad
         # sad

1.3 输出表达式

print(1 + 1)  # 2

1.4 输出至文件

# open 文件路径+模式(a+表示有该文件路径就打开,没有就创建)
fp = open('D:/hello_world.txt', 'a+')
# print+close
print('hello world!', file=fp)

2 input函数

x = input("input x:")  # input x:
y = input("input y:")  # input y:
print(int(x) + int(y))  # 输出x、y之和

3 运算符

3.1 算术运算符

# 1 加: +
# 2 减: -
# 3 乘: *
# 4 除: /
print(3 / 2)  # 1.5
# 5 整除: //
print(3 // 2)  # 1
print(3 // -2)  # -2 (向下取整)
# 6 取余: %
# 7 幂运算: **
print(3 ** 2)  # 9

3.2 位运算符

# 按位与:&
# 按位或:|
# 左右位移(缺位补0):<<,>>
# 异或:^
# 取反:~

3.3 比较运算符

# 值比较:==,!=
# 标识比较:is ,is not

在Python中，‘is’ 和 ‘==’ 是两个用于比较对象的运算符，它们有以下的不同点：

• ‘is’ 用于比较两个对象的内存地址是否相同，即判断两个对象是否是同一个对象。而==用于比较两个对象的值是否相等，即判断两个对象的内容是否相同。
• 对于不可变对象，比如数字、字符串等，‘is’ 和 ‘==’ 的行为是一致的，即在一些情况下，Python解释器会自动对相同的不可变对象进行共享，因此这些对象的内存地址也是相同的。
• 但是对于可变对象，比如列表、字典等，‘is’ 和 ==’ 的行为是不一致的，因为它们在每次创建时都会分配新的内存地址，因此即使内容相同，它们的内存地址也是不同的。

下面是一个例子，说明 ‘is’ 和 ‘’==’ 的区别：

a = [1, 2, 3]
b = [1, 2, 3]
c = a
print(a == b)  # True，因为a和b的值相同
print(a is b)  # False，因为a和b是不同的对象
print(a is c)  # True，因为a和c是同一个对象

3.4 布尔运算符

# 与:and
# 或:or
# 非:not
# in,not in

3.5 赋值运算符

# 参数赋值:+=,-=...
# 链式赋值:x=y=z=2
# 系列解包赋值:x,y,z=1,2,3   x,y=y,x

4 程序结构

4.1 选择结构

a = 2
if a > 2:
    print('a>2')
elif a == 2:
    print('a=2')
else:
    print('else')
# 条件表达式
print('a=2' if a == 2 else 'else')
# pass语句:占位

4.2 循环结构

4.2.1 range函数

# r=range(stop): 0开始，到stop-1为止的步长为一的序列
# r = range(start,stop): start开始，到stop-1为止的步长为一的序列
# r = range(start,stop,step): start开始，到stop-1为止的步长为step的序列
# print(list(r))

4.2.2 while循环

i = 1
while i < 100:
    i += 1

4.2.3 for-in循环

for i in 'hello':
    print(i)  # h e l l o
for i in range(0, 10, 2):
    print(i)  # 0 2 4 6 8
# 注意:else与 while、for-in 配合时，如果没有break则会进入该else

4.2.4

5 简单变量类型

5.1 变量概念

# 标识:内存地址
print('标识:', id(name))
# 类型:数据类型
print('类型:', type(name))
# 值
print('值:', name)
# 多次赋值时变量指向新空间

5.2 整数 int

# 二进制
print(0b10)  # 2
# 八进制
print(0o10)  # 8
# 十进制
print(10)  # 10
# 十六进制
print(0x10)  # 16

5.3 浮点数 float

实际上，python在处理浮点数时会出现精度问题,为了寻求精确值需要做一些操作。

在Python中，Decimal是一个内置的数据类型，用于处理高精度的十进制数，支持浮点数运算、四舍五入、精度控制等功能。相比于Python中的float类型，Decimal可以避免一些舍入误差和精度问题。

使用Decimal需要先导入decimal模块：

from decimal import Decimal

然后可以通过传递一个字符串或数字来创建一个Decimal对象：

a = Decimal('0.1')
b = Decimal(0.1)

注意，使用字符串创建Decimal对象时，需要将数值用引号括起来，否则会产生舍入误差：

# 观察3.3
print(Decimal(3.3))  # 3.29999999999999982236431605997495353221893310546875
print(Decimal('3.3'))  # 3.3

Decimal对象支持基本的算术运算符，如加、减、乘、除：

a = Decimal('0.1')
b = Decimal('0.2')
c = a + b  # Decimal('0.3')
d = a * b  # Decimal('0.02')

除此之外，Decimal对象还支持舍入操作和精度控制。可以通过调用quantize()方法来指定精度和舍入方式：

a = Decimal('0.1234')
b = a.quantize(Decimal('0.01'), rounding='ROUND_HALF_UP')
# Decimal('0.12')

在这个例子中，我们将a的精度设置为0.01，同时使用ROUND_HALF_UP的舍入方式，将a四舍五入为0.12。

具体的舍入方式如下：

• ROUND_CEILING: 向正无穷舍入
• ROUND_DOWN: 向零方向舍入
• ROUND_FLOOR: 向负无穷舍入
• ROUND_HALF_DOWN: 朝最近的一边舍入，如果距离两边相等，则向下舍入
• ROUND_HALF_EVEN: 朝最近的一边舍入，如果距离两边相等，则向最近的偶数舍入
• ROUND_HALF_UP: 朝最近的一边舍入，如果距离两边相等，则向上舍入
• ROUND_UP: 向远离0的方向舍入
• ROUND_05UP: 与ROUND_UP类似，但是当舍弃部分的最高位为5时，向上舍入（如1.25 -> 1.3，-1.25 -> -1.2）

需要注意的是，由于Decimal对象的计算速度较慢，因此在进行高精度计算时应该慎重使用。同时，Decimal对象的精度设置需要根据具体的应用场景来确定，不应盲目追求高精度。

更方便地，round() 作为 Python 内置的函数，可以用于用于对浮点数进行四舍五入取整操作。其语法格式为：

round(number[, ndigits])

其中，number 为要进行取整操作的浮点数，ndigits 表示保留小数位数，默认为 0。当 ndigits 为正数时，number 保留到小数点后 ndigits 位；当 ndigits 为负数时，number 的整数部分保留到小数点前 -ndigits 位，小数部分取整。

例如：

round(3.14159)     # 输出 3
round(3.14159, 2)  # 输出 3.14
round(123.456, -1) # 输出 120.0

需要注意的是，round() 函数在进行取整时，遵循的是“四舍六入五成双”的规则，即当要保留的小数位数的后一位为 5 时，取决于 5 前面的数字是奇数还是偶数。如果是奇数，则向上进位；如果是偶数，则向下舍去。这种规则能够尽可能避免舍入误差带来的影响。

5.4 布尔型

print(True + 1)  # 2
print(False + 1)  # 1
print(bool(True + 1))  # True
print(bool(False + 1))  # True
print(bool(True - 1))  # False
# True -> 1
# False -> 0

5.5 字符串

5.5.1 字符串的查询

s1 = 'hello_world_hello_world'
# (1) index():子串第一次出现位置,找不到抛出ValueError异常
i1 = s1.index('ll')
print(i1)  # 2

# (2) rindex():子串最后一次出现位置,找不到抛出ValueError异常
i2 = s1.rindex('ll')
print(i2)  # 14

# (3) find():子串第一次出现位置,找不到返回-1
i1 = s1.find('ll')
print(i1)  # 2

# (4) rfind():子串最后一次出现位置,找不到返回-1
i2 = s1.rfind('ll')
print(i2)  # 14

5.5.2 字符串的大小写转换

s2 = 'Hello world HELLO hello'
# (1) upper():全转大写
print(s2.upper())  # HELLO WORLD HELLO HELLO

# (2) lower():全转小写
print(s2.lower())  # hello world hello hello

# (3) swapcase():大小写交换
print(s2.swapcase())  # hELLO WORLD hello HELLO

# (4) capitalize():第一个字符大写,其余均小写
print(s2.capitalize())  # Hello world hello hello

# (5) title():每个单词第一个大写,其余均小写
print(s2.title())  # Hello World Hello Hello

5.5.3 字符串的内容对齐

s2 = 'Hello world HELLO hello'

# (1) center():居中对齐
print(s2.center(30, '*'))  # ***Hello world HELLO hello****

# (2) ljust():左对齐
print(s2.ljust(30, '*'))  # Hello world HELLO hello*******

# (3) rjust():右对齐
print(s2.rjust(30, '*'))  # *******Hello world HELLO hello

# (4) zfill():右对齐,左边用0填充(参数不能指定填充字符)
print(s2.zfill(30))  # 0000000Hello world HELLO hello

5.5.4 字符串的劈分

在Python中，split()是一个内置的字符串方法，用于将一个字符串按照指定的分隔符进行拆分，并返回一个由拆分后的子字符串组成的列表。

split()方法的基本语法如下：

cssCopy code
str.split([sep[, maxsplit]])

其中，sep是可选的分隔符参数，如果不指定，则默认使用空格作为分隔符。maxsplit是可选的参数，用于指定最大的拆分次数。

下面是一些示例：

# 使用默认分隔符空格拆分字符串
str1 = "hello world"
result1 = str1.split()
print(result1)  # ['hello', 'world']

# 按照指定分隔符拆分字符串
str2 = "apple,banana,orange"
result2 = str2.split(',')
print(result2)  # ['apple', 'banana', 'orange']

# 指定最大拆分次数
str3 = "one,two,three,four,five"
result3 = str3.split(',', maxsplit=2)
print(result3)  # ['one', 'two', 'three,four,five']

需要注意的是，如果分隔符在字符串中不存在，则split()方法会返回一个只包含原字符串的列表。另外，如果分隔符出现在字符串的开头或结尾，则返回的列表的第一个或最后一个元素可能为空字符串。

类似的还有rsplit，其判断逻辑从右到左，下面是两者的区别

s2 = 'hello my world'
# split():
print(s2.split(' ', 1))  # ['hello', 'my world']
print(s2.split(' '))  # ['hello', 'my', 'world']
# rsplit()
print(s2.rsplit(' ', 1))  # ['hello my', 'world']
print(s2.rsplit(' '))  # ['hello', 'my', 'world']

5.5.5 字符串的合并

s2 = 'Hello world HELLO hello'
t1 = ['123', '456']
print('|'.join(t1))  # 123|456
print('|'.join('123456'))  # 1|2|3|4|5|6

5.5.6 字符串替换

s2 = 'Hello world HELLO hello'
print(s2.replace('hello', 'bye'))  # Hello world HELLO bye

5.5.7 字符串的比较

# <, <=, >, >=, ==, !=

5.5.8 字符串的切片

# [start:stop:step]

5.5.9 格式化字符串(利用占位符)

类似C语言中带占位符的字符串表示：

me = 'hello'
you = 'world'
# (1) 占位符用'%':%d,%10d(10表示宽度),%f,%10.2f(宽度、小数点后位数同时表示)
print('i am %s, you are %s' % (me, you))  # i am hello, you are world

# (2) 占位符用'{}':小数点位数3位可以表示为{0:.3f},不加f就是直接表示总位数为3
print('i am {0}, you are {1} , {0} {1}'.format(me, you))

5.6 类型转换

# str()
# int():文字类和小数字符串无法转换,浮点数取整
# float():文字类字符串无法转换,整数转换时末尾.0

6 组合数据类型

6.1 列表 list

• 列表 []: 类似数组的可变序列

6.1.1 列表的创建

lst1 = ['hello', 'world', '547']

6.1.2 列表内元素索引

'''
内部定义：
def index(self,
          __value: _T,
          __start: int = ...,
          __stop: int = ...) -> int
'''
lst1 = ['hello', 'world', '547']

print(lst1.index('547'))  # 2
print(lst1.index('547', 1, 3))  # 2

6.1.3 依靠索引获取列表内单个元素

在python中，可用正负正数方便的表示正逆索引：

lst1 = ['hello', 'world', '547']

# 正向索引
print(lst1[2])  # 547 
# 逆向索引
print(lst1[-1])  # 547

6.1.4 依靠切片获取列表内多个元素

在Python中，使用列表切片可以快速地获取列表的子集，切片的结果是一个新的列表。

列表切片的基本语法如下：

list[start:stop:step]

其中，start表示切片开始的索引位置（包含），stop表示切片结束的索引位置（不包含，默认为列表的最后一个元素的后一位置），step表示切片的步长（默认为1）。

# 获取列表的前三个元素
my_list = [1, 2, 3, 4, 5]
result1 = my_list[:3]
print(result1)  # [1, 2, 3]

# 获取列表的最后两个元素
result2 = my_list[-2:]
print(result2)  # [4, 5]

# 获取列表的第二个和第四个元素
result3 = my_list[1:4:2]
print(result3)  # [2, 4]

# 切片可以用来复制一个列表
my_list_copy = my_list[:]

# 注意：切片后片操作返回的是原列表的一个子集，不会影响原列表，即产生新的对象,所以索引id是不同的
lst1 = ['hello', 'world', '547']
print(lst1, id(lst1))  # ['hello', 'world', '547'] 1412139432136
print(lst1[2::-1], id(lst1[2::-1]))  # ['547', 'world', 'hello'] 1412139430664

6.1.5 列表元素的存在判断和遍历

lst1 = ['hello', 'world', '547']

# 判断
print('547' in lst1)  # True
# 遍历
for i in lst1:
    print(i)  # hello  world  547

6.1.6 列表元素的增加

lst3 = [1, 2, 3]
lst4 = [4, 5, 6]

# (1) append:列表末尾添加一个元素
lst3.append(lst4)
print(lst3)  # [1, 2, 3, [4, 5, 6]]

# (2) extend:列表末尾添加N个元素
lst3.extend(lst4)  
print(lst3)  # [1, 2, 3, 4, 5, 6]

# (3) insert:列表任意处添加一个元素
'''
def insert(self,
           __index: int,
           __object: _T) -> None
'''
lst3.insert(1, 0)
print(lst3)  # [1, 0, 2, 3] 

# (4) 切片赋值:列表任意处添加N个元素
# [start:stop:step]
# 覆盖式赋值
lst3[1:] = lst4
print(lst3)  # [1, 4, 5, 6]
# 插入式赋值
lst3[1:1] = lst4
print(lst3)  # [1, 4, 5, 6, 2, 3]

6.1.7 列表元素的删除

lst5 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# (1) remove():删除给定值的重复元素中的第一个元素
lst5.remove(1)
print(lst5, id(lst5))  # [2, 3, 4, 5, 6, 7, 8, 9, 10] 1684844231176

# (2) pop():删除给定索引处的一个元素,不指定索引则删除最后一个元素
lst5.pop(0)
print(lst5, id(lst5))  # [2, 3, 4, 5, 6, 7, 8, 9, 10] 1684844231176

# (3) 切片赋值:删除N个元素
# [start:stop:step]
lst5[1:8] = []
print(lst5, id(lst5))  # [1, 9, 10] 1684844231176

# (4) clear():清空列表
lst5.clear()
print(lst5, id(lst5))  # [] 1684844231176

# (5) del:删除列表
del lst5
print(lst5, id(lst5))  # NameError: name 'lst5' is not defined

6.1.8 列表元素的修改

# 指定索引赋新值
# 指定切片赋新值

6.1.9 列表元素的排序

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

# (1) 调用list的sort()方法:原列表变化,不产生新的列表
print('before :', lst6, id(lst6))  # before : [2, 3, 5, 1, 4] 1859791534664
lst6.sort(reverse=True)
print('after :', lst6, id(lst6))  # after : [5, 4, 3, 2, 1] 1859791534664
lst6.sort(reverse=False)
print('after :', lst6, id(lst6))  # after : [1, 2, 3, 4, 5] 1859791534664

# (2) 调用内置函数sorted():原列表不变,产生新的列表
new_lst = sorted(lst6, reverse=True)
print('after :', new_lst, id(new_lst))  # after : [5, 4, 3, 2, 1] 1859791534600

6.1.10 列表生成式

# example：
new_lst = [i ** 3 for i in range(1, 10, 2)]
print(new_lst)  # [1, 27, 125, 343, 729]

6.2 字典 dict

• 字典 {}: 以键值对(key-value)方式存储数据的可变序列

6.2.1 字典的创建

# (1) 使用 '{...}' 赋值
age = {'A': 20, 'B': 21, 'C': 19}
print(age, type(age))  # {'A': 20, 'B': 21, 'C': 19} <class 'dict'>

# (2) 使用dict()创建
student = dict(name='A', age=20)
print(student, type(student))  # {'name': 'A', 'age': 20} <class 'dict'>

6.2.2 字典元素的查询

age = {'A': 20, 'B': 21, 'C': 19}

# (1) 直接通过dict_name[key]:若找不到则抛出KeyError
print('age of A:', age['A'])  # age of A: 20
# print('age of D:', age['D'])  # KeyError: 'D'

# (2) get方法取值:若找不到不会抛出KeyError而是返回None(也可以自己设置默认value返回值)
print('age of A:', age.get('A'))  # age of A: 20
print('age of D:', age.get('D', 22))  # age of D: 22 ,返回默认值22

6.2.3 字典元素的增加和修改

# 直接赋值

6.2.4 字典元素的删除

age = {'A': 20, 'B': 21, 'C': 19}

# (1) 使用del删除一个元素
print('A' in age)  # True
del age['A']  # 删除
print('A' in age)  # False
print(age)  # {'B': 21, 'C': 19}

# (2) 清空
age.clear()
print(age)  # {}

除了del，还可以使用pop()方法可以删除指定键对应的键值对，并返回被删除的键值对的值。其基本语法如下：

dict.pop(key[, default])

其中，dict是指定的字典对象，key是要删除的键，default是可选参数（这里的方括号表示该参数是可选的），用于指定键不存在时的默认值。

下面是一个示例：

# 创建一个字典对象
my_dict = {'name': 'John', 'age': 25, 'gender': 'male'}

# 删除指定的键值对，并返回被删除的值
value = my_dict.pop('age')

# 输出删除后的字典和被删除的值
print(my_dict)  # {'name': 'John', 'gender': 'male'}
print(value)    # 25

需要注意的是，如果指定的键不存在，使用del语句会抛出KeyError异常，而使用pop()方法不一定会抛出异常，而是会返回指定的默认值（如果指定了的话）

6.2.5 字典元素的遍历

age = {'A': 20, 'B': 21, 'C': 19}

for i in age:
    print(i, age[i], age.get(i))
'''
A 20 20
B 21 21
C 19 19
'''

6.2.6 字典视图

age = {'A': 20, 'B': 21, 'C': 19}

# (1) keys(): 获取所有keys
keys = age.keys()
print(keys, type(keys))  # dict_keys(['A', 'B', 'C']) <class 'dict_keys'>

# (2) values(): 获取所有values
values = age.values()
print(values, type(values))  # dict_values([20, 21, 19]) <class 'dict_values'>

# items(): 获取所有keys-values键值对
items = age.items()
print(items, type(items))  # dict_items([('A', 20), ('B', 21), ('C', 19)]) <class 'dict_items'>
print(list(items))  # [('A', 20), ('B', 21), ('C', 19)], 其中(,)为元组, 整个[....]是由元组为元素组成的列表

6.2.7 字典生成式

# 内置函数zip()，后文有介绍
# 字典生成式
name = ['A', 'B', 'C']
age = [20, 21, 22]
student = {name: age for name, age in zip(name, age)}
print(student)  # {'A': 20, 'B': 21, 'C': 22}

6.3 集合 set

• 集合 {}: 可变序列,相当于没有value的字典(说明也是无序无重复的)

6.3.1 集合的创建

# 1.集合的创建
# (1) 用{}赋值
s1 = {'hello', 'world', 1, 2, 1}
print(s1)  # {'world', 2, 'hello', 1}

# (2) 用内置函数set()
s2 = set(range(4))
print(s2)  # {0, 1, 2, 3}

6.3.2 集合元素的判断

# in
# not in

6.3.3 集合元素的增加

s3 = {1, 2, 3, 4, 5}

# (1) add(): 添加一个元素
s3.add(6)
print(s3, id(s3))  # {1, 2, 3, 4, 5, 6} 1844112449608

# (2) update(): 添加N个元素
s3.update([-1, -2])  # {1, 2, 3, 4, 5, 6, -2, -1} 1844112449608
print(s3, id(s3))

6.3.4 集合元素的删除

s4 = {1, 2, 3, 4, 5}

# (1) remove(): 删除指定元素, 找不到会抛出异常
s4.remove(1)
print(s4, id(s4))  # {2, 3, 4, 5} 1705597133096

# (2) discard():删除指定元素, 不会抛出异常
s4.discard(1)
print(s4, id(s4))  # {2, 3, 4, 5} 1705597133096

# (3) pop():无参, 删除随机元素
s4.pop()
print(s4, id(s4))  # {3, 4, 5} 1705597133096

# (4) clear():清空集合
s4.clear()
print(s4, id(s4))  # set() 1705597133096

6.3.5 集合间关系

sx = {1, 2, 3, 4, 5}
sy = {1, 2, 3, 4}

# (1) 相等关系
print(sx == sy)  # False
print(sx != sy)  # True

# (2) 子集关系与超集关系
print(sx.issubset(sy))  # False
print(sy.issubset(sx))  # True
print(sx.issuperset(sy))  # True
print(sy.issuperset(sx))  # False

# (3) 交集关系
print(sx.isdisjoint(sy))  # 有交集, 为False
print(sy.isdisjoint(sx))  # 有交集, 为False

6.3.6 集合间操作

sx = {1, 2, 3, 4, 5}
sy = {1, 2, 3, 4}

# (1) 交集
print(sx.intersection(sy))  # {1, 2, 3, 4}
print(sx & sy)  # {1, 2, 3, 4}
# (2) 并集
print(sx.union(sy))  # {1, 2, 3, 4, 5}
print(sx | sy)  # {1, 2, 3, 4, 5}
# (3) 差集
print(sx.difference(sy))  # {5}
print(sx - sy)  # {5}
print(sy.difference(sx))  # set()
print(sy - sx)  # set()
# (4) 对称差集
print(sx.symmetric_difference(sy))  # {5}
print(sx ^ sy)  # {5}

6.3.7 集合生成式

new_set = {i ** 3 for i in range(1, 10, 2)}
print(new_set, type(new_set))  # {1, 343, 729, 27, 125} <class 'set'>

6.4 元组 tuple

6.4.1 元组的创建

元组 (): 不可变序列，类似于列表，但元组中的元素不可修改。元组使用小括号 () 来表示，其中的元素用逗号 , 隔开，可以包含任意类型的数据，包括其他的元组。例如：

t0 = 'hello', 'world', 547
t1 = ('hello', 'world', 547)
t2 = tuple(('hello', 'world', 547))
# 元组中只有一个元素时需要在后面加上逗号
t3 = ('hello',)  
print(t0, t1, t2, t3)  # ('hello', 'world', 547) ('hello', 'world', 547) ('hello', 'world', 547) ('hello',)

6.4.2 元组的遍历

for i in t0:
    print(i)

元组的不可变性使其在某些情况下更加安全和高效，例如可以用元组作为字典的键，也可以用作函数的返回值，避免了不必要的数据拷贝和处理。

7 常用的数据迭代处理

在编程中，我们经常需要对数据进行处理、过滤、转换等操作。迭代处理数据就是将一个包含多个元素的数据集合（如列表、元组、字典等）中的每个元素依次取出来，经过指定的处理、过滤或计算后，生成一个新的数据集合或结果。

例如，我们可以通过迭代处理数据来实现以下功能：

• 对列表中的每个元素进行平方或其他数学运算，返回一个新的列表。
• 对字典中的每个键值对进行过滤或修改，返回一个新的字典。
• 对文本中的每个单词进行处理，如分割、过滤、转换大小写等，返回一个新的文本。

Python提供了许多内置函数和方法，可以方便地进行迭代处理数据，例如zip()、enumerate()、map()、filter()等。这些函数可以使我们的代码更加简洁和高效，同时也更易于理解和维护。

7.1 zip()

zip()函数可以将多个可迭代对象打包成元组。如果可迭代对象的长度不同，则以最短的长度为准。

语法格式为：

zip(*iterables)

参数iterables是可迭代的对象，可以是多个，用逗号,隔开。例如：

a = [1, 2, 3]
b = ['a', 'b', 'c']
c = zip(a, b)

以上代码将列表a和b打包成一个zip对象c，其中c包含了a和b对应位置上的元素组成的元组。可以通过list()函数将zip对象转换成列表，查看打包结果：

print(list(c))  # [(1, 'a'), (2, 'b'), (3, 'c')]

7.2 enumerate()

enumerate()函数可以将一个可迭代对象中的每个元素和它的索引组成一个元组，返回一个可迭代的enumerate对象。

语法格式为：

enumerate(iterable, start=0)

参数iterable是可迭代的对象，例如列表、元组、字符串等；参数start是可选的，表示起始索引值，默认为0。

例如，对于列表[1, 2, 3]，可以使用enumerate()函数遍历并输出每个元素和它的索引值：

a = [1, 2, 3]
for i, x in enumerate(a):
    print(i, x)

以上代码将输出：

0 1
1 2
2 3

其中，i表示索引值，从0开始逐个递增；x表示对应的元素值。

可以使用enumerate()函数的start参数指定起始索引值，例如：

a = ['apple', 'banana', 'orange']
for i, x in enumerate(a, start=1):
    print(i, x)

以上代码将输出：

1 apple
2 banana
3 orange

7.3 map()

map()函数：将一个可迭代对象中的每个元素按照指定的函数进行处理，返回一个可迭代的map对象。语法格式为：

map(function, iterable, ...)

其中，function是对每个元素进行处理的函数，iterable是可迭代的对象，可以是多个，用逗号,隔开。例如：

def square(x):
    return x * x

a = [1, 2, 3]
b = map(square, a)
print(list(b))  # [1, 4, 9]

以上代码将列表a中的每个元素进行平方处理，返回一个可迭代的map对象b，可以通过list()函数将其转换为列表查看结果。

7.4 filter()

filter()函数：将一个可迭代对象中的每个元素按照指定的条件进行过滤，返回一个可迭代的filter对象。语法格式为：

filter(function, iterable)

其中，function是对每个元素进行条件判断的函数，iterable是可迭代的对象。例如：

def is_odd(x):
    return x % 2 == 1

a = [1, 2, 3, 4, 5]
b = filter(is_odd, a)
print(list(b))  # [1, 3, 5]

以上代码将列表a中的奇数元素过滤出来，返回一个可迭代的filter对象b，可以通过list()函数将其转换为列表查看结果。

8 函数

8.1 函数的参数传递

# (1)参数传递对实参的影响
# 不可变对象函数体内改变不会影响实参的值,但可变对象会.

# (2)参数传递的方式
def minus(parma, parmb):
    return parma - parmb
# 位置传递参数
print(minus(10, 5))  # 5
# 关键字传递参数
print(minus(parmb=10, parma=5))  # -5

8.2 返回值数量

# 函数的返回值可有可无,多个返回值时返回一个元组

8.3 函数的参数定义

# (1) 函数参数能定义为默认值,与默认值不符时才会接受参数
def fun1(a, b=20):
    return a + b
print(fun1(10))  # 30
print(fun1(10, 10))  # 20

# (2) 个数可变的参数
# a.个数可变的位置参数:结果是一个元组
def fun2(*args):
    print("fun2:", args)

fun2(1, 2, 3)  # fun2: (1, 2, 3)

# b.个数可变的关键字参数:结果是一个字典

def fun3(**args):
    print("fun3:", args)

fun3(a=1, b=2, c=3)  # fun3: {'a': 1, 'b': 2, 'c': 3}

# c.个数可变的位置参数在前,关键子参数在后,当俩个参数类型都存在时必须按这个顺序
def fun4(*args1, **args2):
    print(args1, args2)

fun4(1, 2, 3, a=1, b=2, c=3)  # (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}

9 异常处理

# try-except-else-finally
import traceback

try:
    #   x1 = int(input('整数1:'))
    #   x2 = int(input('整数2:'))
    x1 = x2 = 2
    ans = x1 / x2
except BaseException as e:
    # traceback.print_exc()  # 可用traceback模块打印异常信息
    print("error,", e)
else:
    print("ans: ", ans)
finally:
    print("over")

10 面向对象基础

10.1 类的定义与对象的创建

# 类的定义
class Student:
    # 类属性
    cnt = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 实例方法
    def printself(self):
        print(self.name, self.age)

    # 类方法
    @classmethod
    def cm(cls):
        cls.cnt += 1
        print('this is a classmethod')

    # 静态方法
    @staticmethod
    def sm():
        print('this is a staticmethod')


# 类方法和静态方法调用
Student.cm()  # this is a classmethod
Student.sm()  # this is a staticmethod

# 对象的创建与调用
stu1 = Student('123', 20)
stu1.cm()  # this is a classmethod
stu1.sm()  # this is a staticmethod
stu1.printself()  # 123 20
Student.printself(stu1)  # 123 20

# 动态绑定属性(该属性仅仅会出现在该实例中)
stu1.sex = '男'
print(stu1.sex)  # 男


# 动态绑定方法
def walk():
    print("walk")


stu1.walk = walk
stu1.walk()  # walk

其中，类方法和静态方法的主要区别在于它们的调用方式和方法内部对类属性和实例属性的访问方式。

• 调用方式：类方法通过类名进行调用，而静态方法可以通过类名或实例对象调用。
• 方法内部访问：类方法可以访问和修改类属性，但无法访问实例属性；静态方法无法访问和修改类属性和实例属性，它们只是与类相关联的函数。

另外，类方法的第一个参数必须是 cls，表示类本身，而静态方法没有参数限制。

类方法通常用于对类属性进行操作或者提供类的不同构造方法，而静态方法通常用于实现一些与类相关的功能，但不需要访问类属性或实例属性的方法。

10.2 封装（私有属性）

class Car:
    def __init__(self, carname, id):
        self.carname = carname
        self.__jid = id  # __ 表示私有属性,不能在类外面使用,但能在内部使用,外部使用需要调用方法

    def get_id(self):
        return self.__id

    def set_id(self, id):
        self.__id = id


car1 = Car('civic', '0001')
car2 = Car('03+', '0002')
# 调用get方法得到私有属性
print(car1.get_id())  # civic
print(car2.get_id())  # 03+
# 调用set方法修改私有属性
car1.set_id('4321')  
print(car1.get_id())  # 4321(调用get方法)
# 不能直接调用私有属性,但是能通过特殊格式访问到
print(car1.__id)  # AttributeError: 'Car' object has no attribute '__id'
print(car1._Car__id)  # 4321(特殊访问)

10.3 继承（方法重写）

class Person(object):  # Person类继承object类
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def print_info(self):
        print("name = {0}, age = {1}".format(self.name, self.age))


class Student(Person):  # Student类继承Person类
    def __init__(self, name, age, score):  # 方法重写
        super().__init__(name, age)
        self.score = score

    def print_info(self):  # 方法重写
        super().print_info()
        print("score = " + str(self.score))

    def __str__(self):  # --str--()方法的重写
        return 'hello this is class Student'


stu = Student('zhangsan', 18, 100)
stu.print_info()  
'''
name = zhangsan, age = 18
score =100
'''

print(stu)  # hello this is class Student

print(dir(stu))  # 查看所有类属性

10.4 多态

# 在静态语言java中,多态有三个必要条件:继承、重写、父类引用子类对象,调用方法时先确认父类中有该方法,再去调用子类的同名方法
# 而python是动态语言,没有具体类型的概念,只要有这个功能,就能被调用
def start(obj):  # 对象obj不指定类型,只要有start方法就可调用
    obj.start()


class Car:
    def start(self):
        print("voom voom")


class Bike:
    def start(self):
        print("ka ka")


start(Car())  # voom voom
start(Bike())  # ka ka

10.5 类的特殊属性和方法

10.5.1 特殊属性 __dict__:返回类和实例对象所绑定的所有属性和方法的字典

class Student(Person):
    def __init__(self, name, age):
        self.name = name
        self.age = age


s1 = Student('zhangsan', 20)
# __dict__:类对象和实例对象所绑定的所有属性和方法的字典
print(s1.__dict__)  # {'name': 'zhangsan', 'age': 20}
# __mro__:层次结构
print(Student.__mro__)  # (<class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>)

10.5.2 特殊方法 __init__():创建对象初始化

10.5.3 特殊方法 __add__():重写方法得到’+'功能

10.5.4 特殊方法 __len__():内置函数len(重写方法自定义参数类型)

10.5.5 特殊方法 __new__():创建对象,返回根据类创建的一个新的对象

# __init__():创建对象初始化
# __add__():重写方法得到'+'功能
# __len__():内置函数len(重写方法自定义参数类型)
# __new__():创建对象,返回根据类创建的一个新的对象
class Student:
    def __init__(self, name):  # 重写__init__()
        self.name = name

    def __add__(self, other):  # 重写__add__()
        return self.name + ' and ' + other.name

    def __len__(self):  # 重写__len__()
        return len(self.name)

# 重写__init__()后的调用
s1 = Student('zhangsan')
s2 = Student('lisi')

# 重写__add__()后的调用
s3 = s1.__add__(s2)
print(s1 + s2)  # zhangsan and lisi
print(s3)  # zhangsan and lisi

# 重写__len__()后的调用
print('len(s1)=', len(s1), 'len(s2)=', len(s2))  # len(s1)= 8 len(s2)= 4