一、Python 中的基本数据类型包括整数（int）、浮点数（float）、字符串（str）和布尔值（bool）、python3X中新添加的字节（bytes）。¶

1、整数（int）：是不带小数部分的数字，可以是正数、负数或零。在Python中，整数类型没有限制大小，可以处理任意大小的整数，只受限于计算机的内存大小。¶

In [1]:
a=9
print('a的除法运算=',a/2)
print('a的整除运算=',a//2)#整除运算是向下取整
print('a的加法运算=',a+2)
print('a的乘法运算=',a*2)
print('a的类型',type(a))

a的除法运算= 4.5
a的整除运算= 4
a的加法运算= 11
a的乘法运算= 18
a的类型 <class 'int'>

2、浮点数（float）：是带有小数部分的数字，用于表示实数。浮点数在计算机中的表示是不精确的，有时候会产生舍入误差。¶

In [2]:
a=11.5
print('a的除法运算\n a/2=',a/2)
print('a的整除运算\n a//2=',a//2)#整除运算是向下取整，但不一定是整型
print('a的加法运算\n a+2=',a+2)
print('a的乘法运算\n a*2=',a*2)
print('a的类型',type(a))

a的除法运算
 a/2= 5.75
a的整除运算
 a//2= 5.0
a的加法运算
 a+2= 13.5
a的乘法运算
 a*2= 23.0
a的类型 <class 'float'>

3、字符串（str）：是由字符组成的序列，用于表示文本信息。字符串是不可变的，这意味着一旦创建，字符串的内容不能更改。¶

In [3]:
a='这是第一个字符串'
b=' 这是第二个字符串'
In [4]:
a*2#字符串乘法运算
Out[4]:
'这是第一个字符串这是第一个字符串'
In [5]:
a+b#字符串加法运算
Out[5]:
'这是第一个字符串 这是第二个字符串'
In [6]:
print(' '+a+'\n',a[0],a[1])#字符串里面的元素可以用下标表示，下标从0开始是正序，也就是原顺序。

 这是第一个字符串
 这 是
In [7]:
print(' '+a+'\n',a[-1],a[-2],a[-3])#字符串里面的元素可以用下标表示，下标从-1开始是反序，也就是倒序。

 这是第一个字符串
 串 符 字

4、布尔值（bool）：只有两个值，True 和 False，用于逻辑判断和条件表达式。¶

In [8]:
1>2
Out[8]:
False
In [9]:
2>1
Out[9]:
True
In [10]:
a=[i for i in range(5)]
a
Out[10]:
[0, 1, 2, 3, 4]
In [11]:
b =[True,False,True,False,True]
b
Out[11]:
[True, False, True, False, True]
In [12]:
[i for i ,i2 in zip (a,b) if i2  ]#这个列表推导式有点难，但可以更快的了解布尔选择
Out[12]:
[0, 2, 4]
In [13]:
list( zip(a,b))
Out[13]:
[(0, True), (1, False), (2, True), (3, False), (4, True)]
In [14]:
[ i for i in zip(a,b)]
Out[14]:
[(0, True), (1, False), (2, True), (3, False), (4, True)]
In [15]:
b = [True,False,True,False,True]
a = [i for i in range(5)]
for i,i2 in zip(a,b):#zip打包函数
    if i2:
        print(i)

0
2
4

5、复数类型，包括其定义、构成、基本操作（加、减、乘、除等），以及如何在Python中创建和操作复数。¶

实部用整型或者浮点术数,虚部用整型或者浮点术加上J或者j表示（但是浮点数会出现计算错误）

In [16]:
a=4+1j
b=4.1+1J
c=4.0+1j
d=2/3 + 5j
e=2/3 + 3/5j
a,b,c,d,e
Out[16]:
((4+1j), (4.1+1j), (4+1j), (0.6666666666666666+5j), (0.6666666666666666-0.6j))
In [17]:
a+b
Out[17]:
(8.1+2j)
In [18]:
a*b
Out[18]:
(15.399999999999999+8.1j)
In [19]:
a/b
Out[19]:
(0.9769792251544077+0.005614823133071288j)

5、Python中的bytes是一个不可变的序列类型，用于表示字节序列。以下是bytes的一些基本介绍：¶

（1）创建方式：可以通过多种方式创建bytes对象。例如，可以直接传递一个整数列表给bytes()函数，或者使用fromhex类方法从十六进制字符串创建一个bytes对象。

In [20]:
b'I love python',bytes("I love python", encoding='utf-8')
Out[20]:
(b'I love python', b'I love python')
In [21]:
bytes([11, 22, 33]),b'2662',b'\x00\x01\x02\x03\x04',b'\t\r\nAB'
Out[21]:
(b'\x0b\x16!', b'2662', b'\x00\x01\x02\x03\x04', b'\t\r\nAB')

（2）编码转换：bytes类型通常与字符串进行相互转换，这涉及到编码（将字符串转换为bytes）和解码（将bytes转换为字符串）的过程。这个过程通常需要指定字符编码，如UTF-8、ASCII等。

In [22]:
# 使用UTF-8编码将字符串转换为bytes
utf8_string = "Hello, 你好！"
utf8_bytes = utf8_string.encode('utf-8')
print(utf8_bytes)  
# b'Hello, \xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x81'

# 使用UTF-8解码将bytes转换为字符串
decoded_string = utf8_bytes.decode('utf-8')
print(decoded_string)  # Hello, 你好！

# 使用ASCII编码将字符串转换为bytes
ascii_string = "Hello, World!"
ascii_bytes = ascii_string.encode('ascii')
print(ascii_bytes)  # b'Hello, World!'

# 使用ASCII解码将bytes转换为字符串
decoded_ascii_string = ascii_bytes.decode('ascii')
print(decoded_ascii_string)  # Hello, World!

b'Hello, \xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x81'
Hello, 你好！
b'Hello, World!'
Hello, World!

（3） 不可变性：由于bytes对象是不可变的，这意味着一旦创建，它们的内容不能被修改。如果需要可变的字节序列，应该使用bytearray类型。

In [23]:
# 创建一个bytearray对象
ba = bytearray([1, 2, 3])
print(ba)  # bytearray(b'\x01\x02\x03')

# 修改bytearray对象
ba[0] = 42
print(ba)  # bytearray(b'*\x02\x03')

# 向bytearray对象添加元素
ba.append(4)
print(ba)  # bytearray(b'*\x02\x03\x04')

# 从bytearray对象删除元素
del ba[0]
print(ba)  # bytearray(b'\x02\x03\x04')

# 将bytearray对象转换为bytes对象
b = bytes(ba)
print(b)  # b'\x02\x03\x04'

bytearray(b'\x01\x02\x03')
bytearray(b'*\x02\x03')
bytearray(b'*\x02\x03\x04')
bytearray(b'\x02\x03\x04')
b'\x02\x03\x04'

应用场景：bytes类型在处理网络通信、文件读写、加密解密等要用到二进制数据的场景中非常有用。它提供了一种有效存储和操作字节数据的方式。

语法结构：bytes的语法结构为bytes(source, encoding, errors)，其中source是需要转换为字节对象的字符串或可迭代对象；encoding是指定编码方式的参数，默认为'utf-8'；errors是指定编码错误处理方式的参数，默认为'strict'。

与字符串的区别：bytes类型与字符串类型（str）类似，但是字符编码为字节（原始的二进制数据表示形式）而不是Unicode字符。这使得bytes在处理非文本数据时非常有用。

总的来说，bytes类型是Python中用于处理二进制数据的重要工具，它在编程中扮演着关键的角色，尤其是在涉及到底层数据处理和网络通信的情况下。了解和掌握bytes类型的使用是Python编程的一个重要方面。¶

二、接下来看一下Python中的容器类型：而容器类型则包括列表（list）、元组（tuple）、集合（set）和字典（dict）。¶

列表¶

（1）在Python中，列表是一种非常灵活且功能强大的数据结构，可以进行多种基本操作。以下是一些详细的基本操作和它们的实现方式：¶

创建列表：可以通过多种方式创建列表，如直接使用方括号[]定义一个列表，或利用list()函数从一个可迭代对象创建列表。也可以使用列表推导式来根据现有列表创建新列表。

In [24]:
my_list = [1, 2, 3, 'a', 'b', 'c']
my_list
Out[24]:
[1, 2, 3, 'a', 'b', 'c']
In [25]:
my_list2=[[i for i in range(3)],[i for i in range(3)],[i for i in range(3)]]
my_list2
Out[25]:
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]
（2）访问元素：通过索引可以访问列表中的元素，索引从0开始。还可以使用切片操作来访问列表的一部分，这包括指定起始和结束的索引以及步长。¶
In [26]:
my_list = [1, 2, 3, 'a', 'b', 'c']
my_list,my_list[0],my_list[1],my_list[2],my_list[-2],my_list[-1]
Out[26]:
([1, 2, 3, 'a', 'b', 'c'], 1, 2, 3, 'b', 'c')

列表遍历¶

In [27]:
for i in my_list:
    print(i)
my_list

1
2
3
a
b
c
Out[27]:
[1, 2, 3, 'a', 'b', 'c']

（3）列表切片¶

Python列表切片是一种用于访问列表子集的操作，它非常强大且灵活。¶

以下是Python列表切片的一些关键点：¶

1.基本语法：列表切片的基本语法是list[start:stop:step]。其中，start是切片开始的索引，stop是切片结束的索引（不包括这个索引处的元素），step是步长，即每次移动的间隔。如果省略start，则默认从头开始；如果省略stop，则默认到末尾；如果省略step，则默认为1。

2.访问方向：切片操作可以按照从左到右的顺序进行，也可以从右到左，通过负数索引来实现。

3.创建副本：使用切片可以轻松地创建列表的副本，而不会影响原始列表。

4.修改列表：切片操作也可以用来修改列表的内容，例如反转列表或替换列表的一部分。

5.性能优势：切片操作在处理大型列表时具有性能优势，因为它不会创建整个新列表，而是创建一个指向原始列表中特定部分的新视图。

6.注意事项：在使用切片时，需要注意索引的边界条件，以及步长的正负和大小，这些都会影响切片的结果。

7.自定义切片：如果需要，还可以在自定义类中实现切片操作，以便为该类的对象提供类似的功能。

In [28]:
my_list = [0, 1, 2, 3, 4, 5]
# 获取从第1个到第4个元素（不包括第4个）
subset = my_list[1:4]
print(subset)  # 输出： [1, 2, 3]
# 获取从第1个元素开始，每隔1个元素的子集
subset_with_step = my_list[::2]
print(subset_with_step)  # 输出： [0, 2, 4]
# 反转列表
reversed_list = my_list[::-1]
print(reversed_list)  # 输出： [5, 4, 3, 2, 1, 0]

[1, 2, 3]
[0, 2, 4]
[5, 4, 3, 2, 1, 0]
（4）修改元素：可以通过指定索引来更新列表中的元素，或者使用append()方法在列表末尾添加新元素。¶
1、删除指定索引的元素：可以使用del语句或pop()方法来删除指定索引的元素。


使用del语句：del list[index]可以删除指定索引的元素。其中，list是要操作的列表，index是要删除元素的索引。

例如，del my_list[2]将删除my_list中索引为2的元素。

使用pop()方法：list.pop(index)可以删除指定索引的元素并返回该元素。
In [29]:
my_list = [1, 2, 3, 4, 5]
del my_list[2]
print(my_list)  # 输出： [1, 2, 4, 5]

my_list = [1, 2, 3, 4, 5]
removed_element = my_list.pop(2)
print(removed_element)  # 输出： 3
print(my_list)  # 输出： [1, 2, 4, 5]

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

2、删除指定值的元素：可以使用remove()方法来删除第一个匹配到的指定值的元素。如果要删除所有匹配到的值，可以使用循环结构。

remove()方法：通过指定值来删除元素。例如，要删除值为3的元素，可以使用list.remove(3)
In [30]:
my_list = [1, 2, 3, 4, 5]
my_list.remove(3)
print(my_list)  # 输出： [1, 2, 4, 5]

[1, 2, 4, 5]
（5）、清空整个列表：可以使用clear()方法来清空整个列表。¶

clear()方法：清空列表中的所有元素。例如，要清空列表，可以使用list.clear()。

In [31]:
my_list = [1, 2, 3, 4, 5]
my_list.clear()
print(my_list)  # 输出： []

[]

（6）合并列表¶

1、使用加号运算符：可以直接使用+运算符来连接两个列表，生成一个新的列表。
In [32]:
list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged_list = list1 + list2
print(merged_list)  # 输出：[1, 2, 3, 4, 5, 6]

[1, 2, 3, 4, 5, 6]

2、使用extend()方法：如果想要将一个列表的元素添加到另一个列表的末尾，可以使用extend()方法。
In [33]:
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1)  # 输出：[1, 2, 3, 4, 5, 6]

[1, 2, 3, 4, 5, 6]

3、使用列表推导式：列表推导式提供了一种简洁的方式来合并列表，尤其适用于更复杂的列表合并操作。
In [34]:
list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged_list = [item for sublist in [list1, list2] for item in sublist]
print(merged_list)  # 输出：[1, 2, 3, 4, 5, 6]

[1, 2, 3, 4, 5, 6]

4、使用itertools.chain()：如果需要合并多个列表，可以使用itertools.chain()函数，它会创建一个迭代器，按顺序返回各个列表中的元素。
In [35]:
import itertools
list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged_list = list(itertools.chain(list1, list2))
print(merged_list)  # 输出：[1, 2, 3, 4, 5, 6]

[1, 2, 3, 4, 5, 6]

(7)列表分割¶

1、使用切片操作：通过指定起始索引、结束索引和步长来分割列表。
In [36]:
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 分割前三个元素
sublist1 = my_list[:3]
print(sublist1)  # 输出：[1, 2, 3]

# 分割从第4个到第7个元素（不包括第7个）
sublist2 = my_list[3:7]
print(sublist2)  # 输出：[4, 5, 6, 7]

# 分割所有偶数位置的元素
sublist3 = my_list[::2]
print(sublist3)  # 输出：[1, 3, 5, 7, 9]

[1, 2, 3]
[4, 5, 6, 7]
[1, 3, 5, 7, 9]

2、使用循环结构：通过遍历列表并按照一定的条件进行分割。
In [37]:
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 分割小于等于5的元素
sublist1 = []
for item in my_list:
    if item <= 5:
        sublist1.append(item)
print(sublist1)  # 输出：[1, 2, 3, 4, 5]

# 分割大于等于6的元素
sublist2 = []
for item in my_list:
    if item >= 6:
        sublist2.append(item)
print(sublist2)  # 输出：[6, 7, 8, 9, 10]

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

3、使用列表推导式：使用列表推导式可以更简洁地实现分割列表的操作。
In [38]:
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 分割小于等于5的元素
sublist1 = [item for item in my_list if item <= 5]
print(sublist1)  # 输出：[1, 2, 3, 4, 5]

# 分割大于等于6的元素
sublist2 = [item for item in my_list if item >= 6]
print(sublist2)  # 输出：[6, 7, 8, 9, 10]

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

(8)列表排序¶

1、sort() 方法

优点：就地排序，不需要额外的存储空间。

缺点：不稳定排序，时间复杂度为O(n log n)。
In [39]:
lst = [3, 1, 4, 1, 5, 9]
lst.sort()
print(lst)  # 输出：[1, 1, 3, 4, 5, 9]

[1, 1, 3, 4, 5, 9]

2、sorted() 函数

优点：产生一个新的排序列表，原列表不变。稳定排序，时间复杂度为O(n log n)。

缺点：需要额外的存储空间。
In [40]:
lst = [3, 1, 4, 1, 5, 9]
new_lst = sorted(lst)
print(new_lst)  # 输出：[1, 1, 3, 4, 5, 9]

[1, 1, 3, 4, 5, 9]

3、冒泡排序（python 进阶）

优点：简单易懂，适合小列表。

缺点：时间复杂度为O(n^2)，不适合大列表。
In [41]:
def bubble_sort(lst):
    n = len(lst)
    for i in range(n):
        for j in range(0, n-i-1):
            if lst[j] > lst[j+1]:
                lst[j], lst[j+1] = lst[j+1], lst[j]
    return lst
lst = [3, 1, 4, 1, 5, 9]
print(bubble_sort(lst))  # 输出：[1, 1, 3, 4, 5, 9]

[1, 1, 3, 4, 5, 9]

4、快速排序 （python 进阶）

优点：平均时间复杂度为O(n log n)，适合大列表。

缺点：不稳定排序，最坏情况下时间复杂度为O(n^2)。
In [42]:
def quick_sort(lst):
    if len(lst) <= 1:
        return lst
    pivot = lst[len(lst) // 2]
    left = [x for x in lst if x < pivot]
    middle = [x for x in lst if x == pivot]
    right = [x for x in lst if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)
lst = [3, 1, 4, 1, 5, 9]
print(quick_sort(lst))  # 输出：[1, 1, 3, 4, 5, 9]

[1, 1, 3, 4, 5, 9]

(9)列表推导式介绍 [元素 生成方法 条件(可以不添加) ]¶

In [43]:
b=[ i for i in range(11) ]
a=[ i for i in range(11) if i%2==0]
a,b
Out[43]:
([0, 2, 4, 6, 8, 10], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

其他¶

以下是使用Python内置函数len()、max()和min()的示例：

In [44]:
# 创建一个列表
my_list = [1, 2, 3, 4, 5]

# 使用len()函数获取列表长度
length = len(my_list)
print("列表长度：", length)

# 使用max()函数找出列表中的最大元素
max_value = max(my_list)
print("最大元素：", max_value)

# 使用min()函数找出列表中的最小元素
min_value = min(my_list)
print("最小元素：", min_value)

# 列表运算,可以加乘其他就不知道了
my_list = [1, 2, 3, 4, 5]
print('列表运算',my_list*2)
print('列表运算',my_list+[1,23,])

列表长度： 5
最大元素： 5
最小元素： 1
列表运算 [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
列表运算 [1, 2, 3, 4, 5, 1, 23]

元组（tuple）¶

在Python中，元组（tuple）是一种有序的、不可变的序列类型，用于存储多个元素。元组的元素可以是不同类型的数据，例如整数、浮点数、字符串等。

定义：元组是通过圆括号（）或者逗号（ , ） 来创建的，元素之间用逗号分隔。¶
In [45]:
#逗号创建
my_tuple = 1, 2, 3
# 使用圆括号创建元组

my_tuple2 = (1, 2, 3)

# 使用tuple()函数创建元组

my_list2 = [1, 2, 3]

my_tuple3 = tuple(my_list2)

my_tuple4 = tuple(i for i in range(4))#推导式必须要有tuple，不然不认识

my_tuple , my_tuple2, my_tuple3,my_tuple4,'不加tuple()就会这样:',(i for i in range(4))
Out[45]:
((1, 2, 3),
 (1, 2, 3),
 (1, 2, 3),
 (0, 1, 2, 3),
 '不加tuple()就会这样:',
 <generator object <genexpr> at 0x0000023C9BBE2420>)
访问元组：¶
In [46]:
#下标访问
my_tuple =( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[0])  # 输出：0
print(my_tuple[-1])

0
10
特性：¶

元组是不可变的，即一旦创建就不能修改其内容。

元组可以包含不同类型的元素。

元组支持索引和切片操作。

In [47]:
my_tuple =( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
my_tuple[1::2] , my_tuple[::-1]
Out[47]:
((1, 3, 5, 7, 9), (10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))

字典（dict）¶

字典（Dictionary）是Python中的一种数据结构，由键值对组成。它允许使用一个特定的键来访问与之关联的值，从而提供了一种灵活的数据存储和检索方式。以下是关于Python字典的详细介绍：

定义与创建：¶

字典是由一系列键值对构成的集合，其中每个键都与一个值相关联。字典使用花括号 {} 来定义，并且键值对之间用逗号 , 分隔，键和值之间则通 过冒号 : 连接。例如，my_dict = {"key1": "value1", "key2": "value2"} 创建了一个包含两个键值对的字典。

无序性：¶

在Python 3.6之前，字典是无序的，意味着不能保证元素会按照特定的顺序存储或遍历。但从Python 3.7起，字典被保证为有序的，即插入顺序会被记住。

可变性：¶

与元组不同，字典是可变的，可以随时添加、修改或删除其中的键值对。

索引操作：¶

字典中的值可以通过其键来访问。如果尝试访问不存在的键，Python会抛出一个KeyError异常。为了避免这种情况，可以使用get()方法，该方法允许提供一个默认值，当键不存在时返回该默认值。

唯一性：¶

字典中的键必须是唯一的，不允许有重复的键存在。

类型不限：¶

字典中的键和值可以是任意类型，包括但不限于字符串、数字、列表甚至是其他字典。这使得字典非常灵活，可以用于多种不同的数据存储需求。

字典推导式：¶

这是一种从其他可迭代对象创建字典的快捷方式，类似于列表推导式，但更为强大和灵活。

性能：¶

由于字典是基于哈希表实现的，因此它在查找和插入操作上通常具有很高的效率。

总的来说，字典是Python编程中一个非常有用的工具，它以其独特的键值对形式，提供了强大的数据组织和访问能力。了解字典的特性和用法对于编写高效的Python代码至关重要。¶

1、创建¶
1、使用花括号（{}）和冒号（：）：这是最常见的创建字典的方式。在花括号中，通过键值对的形式定义字典元素，其中键和值之间用冒号分隔，不同键值对之间用逗号分隔。例如：
In [48]:
#my_dict={key:value}
#my_dict={键:值}
my_dict = {"name": "Alice", "age": 25, "city": "New York"}
my_dict
Out[48]:
{'name': 'Alice', 'age': 25, 'city': 'New York'}
2、使用内置函数dict()：可以通过dict()函数将其他可迭代对象转换为字典。例如，可以将包含键值对的元组或列表转换为字典
In [49]:
my_tuple = ("name", "Alice", "age", 25, "city", "New York")
my_dict = dict(zip(my_tuple[::2], my_tuple[1::2]))
my_dict
Out[49]:
{'name': 'Alice', 'age': 25, 'city': 'New York'}
3、使用字典推导式：字典推导式是一种简洁的方式来创建字典，它可以根据已有的可迭代对象生成新的字典。例如，可以根据一个列表生成一个平方数的字典：
In [50]:
numbers = [1, 2, 3, 4, 5]
squares = {num: num**2 for num in numbers}
squares
Out[50]:
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
4、使用fromkeys()方法：fromkeys()方法用于创建一个新字典，其中每个键都对应一个指定的值。例如，可以创建一个所有键都对应空字符串的字典：
In [51]:
my_dict = dict.fromkeys(["name", "age", "city"],'')
my_dict
Out[51]:
{'name': '', 'age': '', 'city': ''}
2、常用操作¶
1、增加元素

向字典中添加新的键值对。
In [52]:
# 创建一个空字典
my_dict = {'name': 'Alice', 'age': 25}

# 增加操作
my_dict["name1"] = "Alice"
my_dict["age1"] = 25
print(my_dict)  # 输出： {'name': 'Alice', 'age': 25}

{'name': 'Alice', 'age': 25, 'name1': 'Alice', 'age1': 25}

2、删除元素

从字典中移除指定的键值对。
In [53]:
my_dict = {'name': 'Alice', 'age': 25}
print(my_dict)
del my_dict["age"]
my_dict # 输出： {'name': 'Alice'}

{'name': 'Alice', 'age': 25}
Out[53]:
{'name': 'Alice'}
3、修改

更新字典中指定键的值。
In [54]:
# 修改操作
my_dict = {'name': 'Alice', 'age': 25}
print(my_dict)
my_dict["name"] = "Bob"
print(my_dict)  # 输出： {'name': 'Bob'}

{'name': 'Alice', 'age': 25}
{'name': 'Bob', 'age': 25}

4、查询 

根据键获取字典中的值。
In [55]:
name = my_dict["name"]
print(name)  # 输出： Bob

Bob

5、其他

如果遇到键不存在的情况，可以使用字典的get()方法来避免抛出KeyError。get()方法接受两个参数，第一个参数是要查询的键，第二个参数是可选的，表示如果键不存在时返回的默认值。
In [56]:
# 处理键不存在的情况
city = my_dict.get("city", "没有键city")
name= my_dict.get("name", "没有键name")
print(my_dict)
print(city)  
print(name)

{'name': 'Bob', 'age': 25}
没有键city
Bob

集合（set）。¶

Python中的集合（set）是一个无序且不包含重复元素的序列类型。它的主要特点包括：¶
无序性、唯一性、可变性、集合操作、不可哈希性：¶

集合中的元素没有固定的顺序，这意味着元素在集合中的排列是随机的。

集合会自动去除重复的元素，每个元素在集合中只会出现一次。

与元组和字符串不同，集合是可变的，可以添加或删除元素。

集合支持多种数学上的集合操作，如并集、交集、差集和对称差集等。

集合是不可哈希的，这意味着它们不能作为字典的键或者在其他集合中作为元素出现。

内存优化：¶

由于集合不存储重复元素，它们可以用于去除列表中的重复项，这在某些情况下可以节省内存。

1、集合的创建：¶

创建一个空集合必须使用set()，而不能使用{}，因为后者用于创建空字典。

In [57]:
my_set = set()
#创建一个空集合必须使用set()，而不能使用{}，因为后者用于创建空字典。
#创建一个空集合必须使用set()，而不能使用{}，因为后者用于创建空字典。
#创建一个空集合必须使用set()，而不能使用{}，因为后者用于创建空字典。
my_set2 = { }
print(type(my_set),type(my_set2))  # 输出：set()

# 创建一个非空集合
my_set = {1, 2, 3}
print(my_set)  # 输出：{1, 2, 3}

<class 'set'> <class 'dict'>
{1, 2, 3}
In [58]:
# 集合推导式：你可以使用集合推导式来根据一定的规则生成集合。
squares = {x**2 for x in range(1, 5)}  # {1, 4, 9, 16}
squares
Out[58]:
{1, 4, 9, 16}

2、添加元素到集合¶

In [59]:
my_set = {1, 2, 3}
print(my_set)
my_set.add(4)
print(my_set)  

{1, 2, 3}
{1, 2, 3, 4}

3、从集合中移除元素¶

In [60]:
my_set = {1,5, 2, 3}
print(my_set)
# 从集合中移除元素
my_set.remove(2)
print(my_set)  

{1, 2, 3, 5}
{1, 3, 5}

4、集合运算：¶

可以进行并集（| 操作符或update()方法）、交集（& 操作符）、差集（- 操作符）等。

In [61]:
a = {1, 2, 3}
b = {3, 4, 5}

union_set = a | b  # {1, 2, 3, 4, 5}
intersection_set = a & b  # {3}
difference_set = a - b  # {1, 2}
union_set,intersection_set,difference_set,
Out[61]:
({1, 2, 3, 4, 5}, {3}, {1, 2})

在学习Python的过程中，理解这些基本数据类型和容器类型是非常重要的，因为它们是构建更复杂数据结构和程序的基础。掌握它们的特性和使用场景，可以帮助你更有效地编写代码和解决问题。¶

三、分支结构¶

在Python中，分支结构是通过if、elif和else关键字来实现的。这些关键字用于根据条件执行不同的代码块。

1、if语句：if语句用于检查一个条件是否为真。如果条件为真，则执行if语句下的代码块。否则，跳过该代码块。¶

In [62]:
# if (条件/布尔类型):
#     满足条件后执行。

age = 18

if age >= 18:
    print("你已经成年了")
if True:
    print("你已经成年了")

你已经成年了
你已经成年了

2、if-else语句：if-else语句用于在条件为真时执行一个代码块，否则执行另一个代码块。这可以用于在两个不同的选项之间进行选择。¶

In [63]:
age = 16

if age >= 18:
    print("你已经成年了")
else:
    print("你还未成年")

你还未成年

3、elif语句：elif语句用于在多个条件之间进行选择。当第一个条件为假时，会检查下一个条件，以此类推。只有当所有前面的条件都为假时，才会执行else语句下的代码块。¶

In [64]:
score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

良好

在这些示例中，我们使用了比较运算符（如>=）来比较变量的值。你可以根据需要使用其他比较运算符（如<、>、==等）来构建更复杂的条件表达式。

此外，还可以使用逻辑运算符（如and、or）来组合多个条件。例如：

In [65]:
age = 25
country = "中国"
if age >= 18 and country == "中国":
    print("你已经成年了，并且是中国公民")

你已经成年了，并且是中国公民
In [66]:
age = 25
country = "中国"
if age >= 18  and country == "中国":
    print("你已经成年了，并且是中国公民")

你已经成年了，并且是中国公民

四、循环¶

Python中，循环结构用于重复执行一段代码。主要有两种循环结构：for循环和while循环。

1、for循环：for循环用于遍历一个序列（如列表、元组或字符串），按顺序执行相同的代码块。它的基本语法结构如下：¶

In [67]:
# for 变量 in 序列：
#     循环体
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

apple
banana
cherry

2、while循环：while循环用于在满足某个条件时重复执行一段代码。只要条件为真，循环就会一直执行。它的基本语法结构如下：¶

In [68]:
# while 条件：
#     循环体
sum = 0
i = 1
while i <= 10:
    sum += i
    i += 1
print(sum)

55

在实际编程中，我们经常需要控制循环的执行流程。以下是一些常见的循环控制语句：

break：break语句用于立即终止当前循环，跳出循环体。它通常用于在满足某个条件时提前结束循环。

In [69]:
for i in range(1, 11):
    if i == 5:
        break
    print(i)

1
2
3
4

continue：continue语句用于跳过当前循环的剩余部分，直接进入下一次循环。它通常用于在满足某个条件时跳过当前迭代。

In [70]:
for i in range(1, 11):
    if i % 2 == 0:
        print(f'{i}不是奇数')
        continue
        
    print(i)

1
2不是奇数
3
4不是奇数
5
6不是奇数
7
8不是奇数
9
10不是奇数

五、函数¶

Python的函数模块是指包含一系列函数的代码文件，通常以.py为扩展名。这些函数可以定义在模块中，然后在其他程序中导入并使用。函数模块有助于代码重用和模块化编程。

1、自定义函数¶

函数定义：在Python中，可以使用def关键字来定义一个函数。

返回值处理：函数可以通过return语句返回一个值。如果没有return语句或return后面没有表达式，则函数返回None。

In [71]:
# def 函数名(函数参数):
#     # 函数体
#     # ...
#     return result  #return可以让函数返回函数结果

def add1(a, b):
    c=a + b
    print(c)
    return c

def add2(a, b):
    c=a + b
    print(c)

c=0 
# 如本例 先执行函数体，再返回函数值
add1(1,2) , add2(1,2) , c

3
3
Out[71]:
(3, None, 0)

2、参数传递：在调用函数时，可以通过以下方式传递参数：¶

1、位置参数：按照参数在函数定义中的位置顺序传递。
关键字参数：通过参数名指定参数值。
默认参数：为函数参数提供默认值，如果在调用时没有提供相应的参数值，则使用默认值。
可变参数：使用*args表示接收任意数量的位置参数，使用**kwargs表示接收任意数量的关键字参数。
使用*args表示接收任意数量的位置参数：
当函数需要接收不确定数量的位置参数时，可以在参数列表中使用*args。*args是一个元组，其中包含了传递给函数的所有位置参数。
In [72]:
def print_args(*args):
    for arg in args:
        print(arg)
        
print_args(1, 2, 3)  # 输出：1 2 3

print_args("a", "b", "c")  # 输出：a b c

1
2
3
a
b
c

2、使用**kwargs表示接收任意数量的关键字参数：
当函数需要接收不确定数量的关键字参数时，可以在参数列表中使用**kwargs。**kwargs是一个字典，其中包含了传递给函数的所有关键字参数。

例如，定义一个函数print_kwargs，它接收任意数量的关键字参数并打印它们：
In [73]:
def print_kwargs(**kwargs):
    for key, value in kwargs.items():
        print(key, value)

print_kwargs(a=1, b=2, c=3)  # 输出：a 1 b 2 c 3
print_kwargs(name="Alice", age=25)  # 输出：name Alice age 25

a 1
b 2
c 3
name Alice
age 25

3、匿名函数¶

是一种没有显式定义函数名的函数，通常使用lambda表达式来创建。

匿名函数在Python中是通过lambda关键字来定义的，它允许你快速创建一个简单的、单行的、临时使用的函数，而不需要像常规函数那样先定义函数名。

匿名函数的一般形式是lambda 参数列表： 表达式。这种函数通常用于需要一个简单操作的地方，例如作为其他函数的参数。

匿名函数的特点如下：

简洁性：匿名函数的语法结构非常简单，可以在代码中快速编写和使用。

无需命名：由于不需要为函数指定名称，这有助于减少命名冲突和提高代码的可读性。

单行表达式：匿名函数通常只包含一个表达式，这意味着它们通常用于执行简单的操作。

临时使用：匿名函数通常用于那些不需要重复使用的场景，比如排序、映射等一次性操作。

In [74]:
double = lambda x:  print(2*x)

numbers = [1, 2, 3, 4]
double(numbers )

[1, 2, 3, 4, 1, 2, 3, 4]
In [75]:
double(123)

246