1、开始写代码

　　所有代码都在jupyter notebook中运行，下载地址： https://pan.baidu.com/s/18PYD6h5WoT0zd5N8gTfyEA?pwd=hb8m 提取码: hb8m。

1.1、解释器和编辑器

运行python程序，一般需要一个解释器和编辑器。

解释器：作为高级语言，机器无法直接读懂python代码，要通过解释器来一行一行翻译，把python代码转换成字节码再执行。我们一般说安装python，本质上就是安装python解释器，比如python3.7。
编辑器：一般用pycharm或者vscode或者jupyternotebook；

Pycharm：本质是一个IDE——集成开发环境，拥有代码补全、自动格式化、拼写检查等基础代码功能，还集成了调试器、版本控制工具等。
JupyterNotebook：是以网页的形式打开，可以在浏览器中直接编写和运行代码，代码的运行结果也会直接在代码块下显示，适合科学计算分步骤显示结果，也适合教学使用。

Python程序的运行十分依赖库和环境，如果一台电脑上所有Python程序都共用一整个解释器和环境，那整体就会非常臃肿且难以移植，而且新老版本环境之间会相互影响。

Python虚拟环境venv，顾名思义，venv是在一台电脑上互相独立的不同Python环境，包含解释器、库、各种工具和配置文件等，每一个虚拟环境都相互独立、互不影响。

Pycharm新建虚拟环境

https://blog.csdn.net/didi_ya/article/details/120664678

核心是在【新建项目】时，【Python解释器】选择【Virtualenv】。
不需要自己在文件夹中创建激活虚拟环境。

Jupyter Notebook新建虚拟环境

https://blog.csdn.net/m0_49866160/article/details/136378815

1、在目标文件夹中打开cmd，创建一个虚拟环境，以下代码均在cmd中运行。

python -m venv myenv

2、激活虚拟环境

cd myenv/Scripts
./activate

4、安装ipykernel，并将虚拟环境加入jupyter

pip install ipykernel
python -m ipykernel install --name=your_env_name(虚拟环境名)

3、在虚拟环境激活的情况下，启动 Jupyter Notebook

cd ..
jupyter notebook

之后，就可以在网页上操作这个虚拟环境了，这次coding结束要关闭内核，下次再coding要在cmd中再打开。

1.5、print()函数详解

()中单双引号都可以

print()函数输出字符串'单引号'和"双引号"都可以，必须是英文符号。

print('Hello Word!')

Hello Word!

print("Hello Word!")

Hello Word!

分隔符seq=’’ 结束符end=’’

print()可以打印变量;
打印分隔符用sep=''，位置在()中所有变量后，默认或者不写就是空格，所有字符之间都会用该分隔符。
打印结束符用end=''，位置在()中所有变量后，默认或者不写就是换行符\n。

m = 'Hello'
n = 'Word'
print(m,n,sep=',',end=' ')

Hello,Word

转义字符 \n \t

print()转义字符,在字符串中使用转义字符来打印一些特殊字符，例如换行符 \n，制表符 \t (通常相当于Tab键)。

print('Hello\nWord')

Hello
Word

print('Hello\tWord')

Hello	Word

打印列表list和字典dict

print()打印列表、字典等数据结构。

list_1 = [1,2,3,4,5,6]
dict_1 = {'name':'wang','age':24}

print(list_1)
print(dict_1)

[1, 2, 3, 4, 5, 6]
{'name': 'wang', 'age': 24}

.format()填空占位符{}

print()中的.format()方法。在字符串中插入占位符 {}，然后使用 .format() 方法将变量的值填充到这些占位符中。

name = "Alice"
age = 30

# 使用.format()方法格式化字符串，并填充到print()中的占位符
formatted_string = "Name: {}, Age: {}".format(name, age)

print(formatted_string)

Name: Alice, Age: 30


还可以使用索引或关键字参数来指定.format()，哪个值应该填充到哪个占位符。

# 使用索引,1号位和0号位
formatted_string = "Age:{1},Name:{0}".format(name, age)
print(formatted_string)

# 使用关键字参数
formatted_string = "Name: {name}, Age: {age}".format(name="Alice", age=30)
print(formatted_string)

Age:30,Name:Alice
Name: Alice, Age: 30

f-string直接用{}引入变量名

print()中的f-string方法，是Python 3.6后引入的一种新的字符串格式化方法。
f-string更加简洁和直观，可以直接在字符串中嵌入表达式，在运行时还可以被求值，并将结果插入到字符串中。

name = "Alice"
age = 30

formatted_string = f'Name:{name}, Age:{age}'
print(formatted_string)

Name:Alice, Age:30

x = 10
y = 20

formatted_string = f"{x} + {y} = {x + y}"
print(formatted_string)

10 + 20 = 30

2、math函数库

Python的math函数库提供了许多用于数学运算的函数。
这些函数涵盖了基本的算术运算、数学常数、三角函数、对数函数、幂函数、取整函数等。

使用math库要先import一下。

import math

以下是一些 math 库中常用的函数和常数

2.1 常数

常数
math.pi: 圆周率 π 的值。
math.e: 自然对数的底数 e 的值。
math.tau: τ 的值，等于 2π。
math.inf: 表示正无穷大。
math.nan: 表示非数字。

2.2 算数运算

算术运算
math.fabs(x): 返回 x 的绝对值。
math.pow(x, y): 返回 x 的 y 次幂。
math.sqrt(x): 返回 x 的平方根。
math.factorial(x): 返回 x 的阶乘。
math.gcd(x, y): 返回 x 和 y 的最大公约数。

2.3 三角函数

三角函数
math.sin(x): 返回 x 的正弦值。
math.cos(x): 返回 x 的余弦值。
math.tan(x): 返回 x 的正切值。
math.asin(x): 返回 x 的反正弦值。
math.acos(x): 返回 x 的反余弦值。
math.atan(x): 返回 x 的反正切值。

2.4 对数函数

对数函数
math.log(a,b): 返回 a 的对数，底数为 b（如果未提供，则默认为 e）。
math.log10(x): 返回 x 的以 10 为底的对数。
math.log2(x): 返回 x 的以 2 为底的对数。

print(math.log(25,5))

2.0

2.5 取整和舍入

取整和舍入
math.ceil(x): 返回不小于 x 的最小整数。
math.floor(x): 返回不大于 x 的最大整数。
math.trunc(x): 返回 x 的整数部分，去除小数部分。
math.round(x, n): 返回 x 四舍五入到 n 位小数后的值（如果 n 未提供，则四舍五入到整数）。

2.6 其他函数

其他函数
math.isfinite(x): 检查 x 是否既不是无穷大也不是 NaN。
math.isinf(x): 检查 x 是否是正无穷大或负无穷大。
math.isnan(x): 检查 x 是否是 NaN。
math.copysign(x, y): 返回 x 的绝对值，但符号与 y 相同。

3、写注释

3.1 注释的作用

注释可以使得代码清晰或者跳过不想执行的代码。

# 井号是单行注释

"""
    三引号是多行注释
"""

'\n    三引号是多行注释\n'

3.2 快捷键

在pycharm中，多行注释的快捷键是Ctrl+/ ；
取消注释在此基础上再按一次Ctrl+/ 。

4、数据类型

在Python中，数据类型按照大类分，包括数字类型、序列类型、映射类型、集合类型以及布尔类型等。

1. 数字类型
    整型（int）：例如，1, 100, -5
    浮点型（float）：例如，3.14, -0.001
    复数型（complex）：例如，1+2j, -3.5+4.5j

2. 序列类型
    字符串（str）：例如，'hello', "world"
    列表（list）：例如，[1, 2, 3], ['a', 'b', 'c']
    元组（tuple）：例如，(1, 2, 3), ('a', 'b', 'c')
    范围对象（range）：例如，range(5), range(1, 10, 2)

3. 映射类型
    字典（dict）：例如，{'name': 'Alice', 'age': 25}, {1: 'one', 2: 'two'}

4. 集合类型
    集合（set）：例如，{1, 2, 3}, {'a', 'b', 'c'}
    不可变集合（frozenset）：例如，frozenset([1, 2, 3])

5. 布尔类型
    布尔值（bool）：例如，True, False

6. 二进制类型
    字节（bytes）：例如，b'hello', bytes([72, 101, 108, 108, 111])
    字节数组（bytearray）：例如，bytearray(b'hello')
    内存视图（memoryview）：例如，memoryview(b'hello')
    
7. None类型
    None：表示空值或“无”值。

8. 其他类型
    类型对象（type）：例如，int, str, list
    函数类型：例如，通过def定义的函数。
    模块类型：例如，导入的模块。
    类类型：例如，通过class定义的类。
    生成器（generator）：通过生成器函数（使用yield关键字的函数）创建的迭代器。
    上下文管理器（context manager）：用于with语句的对象，支持资源的自动管理。

4.1 数字类型

4.1.1 整形

Python的整型是动态类型，它们的大小不固定，可以根据需要动态增长。
因此，Python整型可以表示和计算的数字范围，理论上依赖于计算机本身的内存大小。
这一点和C、JAVA等语言不同，它们的整型通常是静态的，具有固定的大小和范围。
由于python的整型是动态的，因此也不存在溢出问题。

在Python中，整型的表示方法有多种，主要包括十进制、二进制、八进制和十六进制。

十进制：
    十进制是整型默认的表示方法，如123、-456。

二进制：
    二进制以0b或0B开头，后面跟随0和1组成的数字序列，
    如0b1010表示二进制的1010，转换为十进制为10。

八进制：
    八进制以0o开头，后面跟随0到7之间的数字序列，
    如0o123表示八进制的123，转换为十进制为83。

十六进制：
    十六进制以0x或0X开头，后面跟随0到9以及a到f（或A到F）之间的字符序列，
    其中a到f（或A到F）分别表示10到15。
    如0x1A3表示十六进制的1A3，转换为十进制为419。
    
在处理二进制数据时，使用二进制更加直观；
在处理文件权限等八进制数据时，使用八进制；
在处理颜色值等十六进制数据时，使用十六进制。

4.1.2 浮点型

在Python中，浮点型数字可以通过直接书写小数形式（如3.14）或科学记数法形式（如1.23e4表示12300）。

浮点型数字在计算机内部通常以科学记数法的形式存储，即m × 2^e的形式，
其中m是尾数（一个介于1和2之间的浮点数，有时也包括0和2），e是指数（一个整数）。
这种表示方法的好处是可以在有限的空间表示非常大的数字，并保持一定的精度。

浮点型和整型的互换

将整型转为浮点型，使用内置的float()函数。
在我们看起来是只出现了一位小数，实际上是元素的数据类型发生了变化。

a = 5
b = float(a)
print(f"b = {b}")
print(f"a的类型是：{type(a)}")
print(f"b的类型是：{type(b)}")

b = 5.0
a的类型是：<class 'int'>
b的类型是：<class 'float'>


将浮点型转为整型，使用内置的int()函数或round()函数。
int()会截断浮点型，只保留整数部分；
round()可以四舍五入。

a = 3.66
b = int(a)
c = round(a)
print(f"a = {a}")
print(f"b = {b}")
print(f"c = {c}")

a = 3.66
b = 3
c = 4

浮点型保留小数位数

使用round()函数,保留小数位数的同时，进行了四舍五入。

a = 3.6666666
b = round(a, 2)
print(b)

3.67


使用%操作符,保留小数位数的同时，进行了四舍五入。

a = 3.6666666
b = "%.2f" % a
print(b)

3.67


使用f-string。

a = 3.6666666
b = f"{a:.2f}"
print(b)

3.67


截断到小数点后而不四舍五入

a = 3.14159
b = int(a * 100) / 100  # 先乘以100，使用int()截断后再除以100
print(b)

3.14

4.2、序列类型

4.2.1、字符串

字符串（String）是由零个或多个字符组成的序列，用于表示文本。
字符串是不可变的，字符串一旦被创建，其内容就不能被更改。
当“修改”字符串时，Python实际上是在内存中创建了一个新的字符串对象，
该对象是修改后的内容，而原始的字符串则保持不变。

字符串的创建

单引号：'Hello, World!'，
双引号："Hello, World!"，
三引号（单引号或双引号均可）：用于创建多行字符串。

print('Hello, World!')
print("Hello, World!")
print('''Hello 
World''')

Hello, World!
Hello, World!
Hello 
World

字符串的索引和切片

索引：字符串中的每个字符都有一个位置索引，类似下标。
从0开始，可以通过索引访问字符串中的特定字符。

s = "Hello"
print(s[0])
print(s[4])

H
o


切片：通过切片可以获取字符串的任意子串。
切片操作使用冒号分隔开始和结束的索引（下标），甚至可以自定义步长。

s = "Hello, World!"
print(s[0:5])
print(s[:5])   # 省略起始索引，表示从字符串开头开始
print(s[7:])   # 省略结束索引，表示到字符串结尾结束
print(s[::2])  # 步长2进行切片，间隔为1，空格也占用了一位

Hello
Hello
World!
Hlo ol!

字符串格式化

百分号（%）格式化：
使用%符号作为占位符，并在其后指定一个格式说明符（s表示字符串，d表示整数）。

name = "Alice"
age = 30
formatted_string = "Name: %s, Age: %d" % (name, age)
print(formatted_string)

Name: Alice, Age: 30


str.format()方法：
使用花括号{}作为占位符，可以通过位置或关键字参数来传递值。

name = "Bob"
age = 25
# 简单的通过前后位置来传递
formatted_string = "Name: {}, Age: {}".format(name, age)
# 使用关键字参数更精确的传递
formatted_string_kw = "Name: {NAME}, Age: {AGE}".format(NAME=name, AGE=age)
print(formatted_string)
print(formatted_string_kw)

Name: Bob, Age: 25
Name: Bob, Age: 25

字符串的比较

按照字符串中字符的Unicode码逐一进行比较。
一般大写<小写，不区分大小写的化要加上.lower()或者.upper()方法。

a = "apple"
b = "banana"
c = "Apple"

print(a < b)  # 'a'的Unicode码点小于'b'
print(a < c)  # 'A'的Unicode码点小于'a'
print(a == "apple")  # True，两个字符串完全相同

# 不区分大小写的比较
print(a.lower() == c.lower())  # True，因为'apple'和'Apple'转换为小写后都是'apple'

True
False
True
True

字符串的迭代

在Python中，字符串是一种可迭代的数据类型。
可以遍历字符串中的每个字符，并逐一处理它们。

my_string = "hello"

for char in my_string:
    print(char)

h
e
l
l
o

字符串的方法和属性

len(s)：返回字符串的长度。
s.upper()：将字符串转换为大写。
s.lower()：将字符串转换为小写。
s.strip()：去除字符串两端的空白字符（或其他指定字符）。
s.split()：根据指定的分隔符将字符串分割成列表。
s.join()：将可迭代对象中的元素以字符串为分隔符连接成一个新的字符串。
s.find()：在字符串中查找子字符串的起始索引，如果找不到则返回-1。
s.replace()：将字符串中的旧子字符串替换为新子字符串。
s.startswith()：检查字符串是否以指定的前缀开始。
s.endswith()：检查字符串是否以指定的后缀结束。

# len(s)：返回字符串的长度。

s = "Hello, world!"
print(len(s))

# s.strip()：去除字符串两端的空白字符（或其他指定字符）。

s = "   Hello, world!   "
print(s.strip()) # 不指定默认去除空白字符

# 去除指定字符
s = "xxxHello, world!xxx"
print(s.strip('x'))

Hello, world!
Hello, world!

# s.split()：根据指定的分隔符将字符串分割成列表。

s = "Hello, world, this is a test"
print(s.split()) # 不指定默认空格是分隔符

# 指定分隔符，用''引用
print(s.split(', '))

# 指定最大分割次数，只分割1次
print(s.split(', ', 1))

['Hello,', 'world,', 'this', 'is', 'a', 'test']
['Hello', 'world', 'this is a test']
['Hello', 'world, this is a test']

# s.join()：将可迭代对象中的元素以字符串为分隔符连接成一个新的字符串

words = ['Hello', 'world', 'this', 'is', 'a', 'test']
print(' '.join(words)) # ''中间有一个空格，就用空格来分割

Hello world this is a test

# s.find()：在字符串中查找子字符串的起始索引，如果找不到则返回-1。

s = "Hello, world!"
print(s.find('world'))
print(s.find('Python'))

7
-1

# s.replace()：将字符串中的旧子字符串替换为新子字符串。

s = "Hello, world! Hello, Python!"
print(s.replace('Hello', 'Hi'))

# 指定替换次数
print(s.replace('Hello', 'Hi', 1))

Hi, world! Hi, Python!
Hi, world! Hello, Python!

# s.startswith()：检查字符串是否以指定的前缀开始。
# s.endswith()：检查字符串是否以指定的后缀结束。

s = "Hello, world!"
print(s.startswith('Hello'))  
print(s.startswith('world'))  

print(s.endswith('Hello'))  
print(s.endswith('world!'))

True
False
False
True

4.2.2、列表

Python中列表用于存储一系列的项目或元素。
这些元素可以是不同类型的数据，比如数字、字符串、甚至是其他列表（即嵌套列表）。

创建列表

# 创建一个包含几个数字的列表
numbers = [1, 2, 3, 4, 5]
print(numbers)

# 创建一个包含字符串的列表
fruits = ["apple", "banana", "cherry"]
print(fruits)

# 创建一个包含不同类型元素的列表
mixed = [1, "two", 3.0, True]
print(mixed)

# 创建一个空列表，常用来提前准备
empty_list = []

[1, 2, 3, 4, 5]
['apple', 'banana', 'cherry']
[1, 'two', 3.0, True]

访问元素

访问元素
列表中的元素可以通过索引（下标）来访问，索引从0开始。
正数表示正着第几个，负数表示倒着第几个。

# 访问第一个元素
print(fruits[0])

# 访问最后一个元素（使用负索引，表示倒数第几个）
print(fruits[-1])

apple
cherry

修改元素

修改元素
通过索引可以直接修改列表中的元素。

# 修改第二个元素
fruits[1] = "blueberry"
print(fruits)

['apple', 'blueberry', 'cherry']

添加元素

添加元素
可以用append()在列尾添加元素，
也可以用insert()在指定位置插入元素，剩下的往后顺推。

# 在末尾添加元素
fruits.append("date")
print(fruits)  

# 在指定位置插入元素，即在原位之前
fruits.insert(1, "elderberry")
print(fruits)

['apple', 'blueberry', 'cherry', 'date']
['apple', 'elderberry', 'blueberry', 'cherry', 'date']

删除元素

删除元素
可以使用remove()方法根据值删除元素；
或使用pop()方法根据索引弹出第几位元素，列表此时只有剩下的元素；
还可以使用del语句按照索引直接删除。

# 根据值删除元素
fruits.remove("blueberry")
print(fruits)

# 根据索引删除元素
removed_fruit = fruits.pop(2)
print(fruits)
print(removed_fruit)

# 使用del语句删除元素
del fruits[1]
print(fruits)

['apple', 'elderberry', 'cherry', 'date']
['apple', 'elderberry', 'date']
cherry
['apple', 'date']

列表遍历

列表遍历
使用for循环遍历列表中的元素。

# for __ in fruits中 ，__ 可以用任意字符来表示，但是要有意义
for fruit in fruits:
    print(fruit)

apple
date

列表推导式

列表推导式
根据某个数学公式来创建并填充列表。

# 创建一个包含0到9的平方的列表
squares = [x**2 for x in range(10)]
print(squares)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

列表嵌套

列表嵌套
列表可以包含其他列表，形成多维数组或矩阵。

# 创建一个2x2的矩阵
matrix = [
    [1, 2],
    [3, 4]
]
print(matrix)

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

列表切片

列表切片
切片操作返回的是一个新的列表，原始列表不会被修改。
list[a,b,n]返回第[a,b)位置的元素，步长为n，间隔为n-1。

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 返回前5项
print(numbers[0:5:])

# 步长为2
print(numbers[::2])

# 反向切片
print(numbers[::-1])

# 反向切片步长为2
print(numbers[::-2])

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

列表的排序和反转

列表的排序和反转
sort() 方法：对列表进行原地排序，不返回新的列表。
sorted() 函数：返回一个新的排序后的列表，不修改原列表。
reverse() 方法：对列表进行原地反转，不返回新的列表。

numbers = [5, 2, 9, 1, 5, 6]
numbers.sort()  # 原地排序
print(numbers)

numbers = [5, 2, 9, 1, 5, 6]
sorted_numbers = sorted(numbers)  # 返回新列表
print(sorted_numbers)  # 输出排序后的列表
print(numbers)  # 输出原列表

numbers = [1, 2, 3, 4, 5]
numbers.reverse()  # 原地反转
print(numbers)

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

列表的合并和拆分

列表的合并和拆分
使用 + 运算符：将两个或多个列表合并成一个新的列表。
使用 * 运算符：重复列表元素以创建新列表。

list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged_list = list1 + list2  # 使用 + 运算符合并
print(merged_list)  

repeated_list = list1 * 3  # 重复三次list1的元素
print(repeated_list)

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

返回某值出现的次数

返回列表中指定值出现的次数
list.count(value)返回列表中指定值出现的次数。

my_list = [1, 2, 3, 2, 4, 2, 5]
count_of_2 = my_list.count(2)
print(count_of_2)

返回某值第一次出现的索引

返回列表中指定值第一次出现的索引
list.index(value)返回列表中指定值第一次出现的索引(下标)。

my_list = [1, 2, 3, 4, 5]
first_index_of_3 = my_list.index(3)
print(first_index_of_3)

4.2.3、元组

元组和列表类似，主要区别是元组不可变，一旦创建，元组内容就不被改变。
所以元组的操作和列表类似，
一般元组被用来作为字典的键。

创建元组

元组用()来表示，虽然方便了，但是在创建单个元组的时候容易和变量赋值混淆。

# 创建一个包含多个元素的元组
my_tuple = (1, 2, 3, 4)

# 创建一个包含单个元素的元组
single_element_tuple = (5,) # 不加逗号会被解释为变量赋值
print(single_element_tuple)
not_a_tuple = (6)  # 这实际上是一个整数，不是元组
print(not_a_tuple)

(5,)
6

元组的操作

元组的操作包括切片、访问、计数、索引、拼接、重复等，和列表基本一样。
注意：元组不能修改某项。
注意：拼接和重复后的元组实际上是形成了一个新的元组。

不可变性带来的好处

由于元组是不可变的，它们在某些情况下比列表更安全、更高效。
例如，作为字典的键或集合的元素时，不可变性保证了数据的一致性和哈希值的稳定性。

注意：
如果元组中的元素是可变的（如列表），那么这些元素的内容可以改变，
但元组本身的结构（即元素的顺序和类型）仍不可变。

# 含有可变元素的元组
mutable_tuple = ([1, 2], [3, 4])

# 修改元组项-列表的内容
mutable_tuple[0].append(5) 
print(mutable_tuple)

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

4.2.4 范围对象

在Python中，范围对象通过内置的range()函数生成。
它表示一个不可变的整数序列，通常用于for循环中生成一系列数字。
范围对象最大的好处就是高效，它们不会存储所有数字，而是根据需要生成它们。

创建范围对象

# 从0到4的整数序列，步长为1
r = range(5)
print(list(r))

# 从1到10（不包含10）的整数序列，步长为2
r = range(1, 10, 2)
print(list(r))

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

在for循环中使用范围对象

这是range()最常用的地方。
注意：
一般step都是正数；如果step为负数，则序列是递减的。
当step为负数时，start应该大于stop，否则循环将为空。

for i in range(10):
    print(i)

for i in range(0,10,2):
    print(i)

4.3、映射类型

4.3.1、字典

字典顾名思义，用于存储键值对（key-value），主要用来检索。
核心是一个键对应一个值。
字典是无序的，它不记录元素插入的顺序。
字典通过键（key）来访问值（value），这使得数据查找和修改操作非常快速。

字典的创建

字典通过花括号 {} 创建，键和值之间用冒号 : 分隔，键值对之间用逗号 , 分隔。

my_dict = {'name': 'ZhangSan', 'age': 25, 'city': 'BeiJing'}
print(my_dict)

{'name': 'ZhangSan', 'age': 25, 'city': 'BeiJing'}


也可以通过 dict() 函数创建空字典，然后添加键值对。

# 这样会直接覆盖字典原来的值
my_dict['name'] = 'LiSi'
my_dict['age'] = 26
print(my_dict)

{'name': 'LiSi', 'age': 26, 'city': 'BeiJing'}

访问字典元素

访问字典元素
使用键来访问字典中的值。

print(my_dict['name'])

LiSi


如果尝试访问不存在的键，会引发 KeyError。
为了避免这种错误，可以使用字典的 get() 方法，
my_dict.get('键值','要返回的默认值')
指定一个默认值，如果键不存在则返回这个默认值。

print(my_dict.get('IP','Nothing Find.'))

Nothing Find.

添加、删除字典元素

如果键不存在于字典中，直接赋值即可添加新的键值对。
使用 del 语句或 pop() 方法删除字典中的键值对。

my_dict['email'] = 'LiSi@example.com'
print(my_dict)

{'name': 'LiSi', 'age': 26, 'city': 'BeiJing', 'email': 'LiSi@example.com'}

del my_dict['city']
print(my_dict)

{'name': 'LiSi', 'age': 26, 'email': 'LiSi@example.com'}

# 用pop方法的时候，要找一个变量来承载弹出的键值对
remove = my_dict.pop('age')

# 会直接输出age的值
print(remove)

print(my_dict)

25
{'name': 'ZhangSan', 'city': 'BeiJing'}

字典的遍历

可以使用 for 循环遍历字典的键、值或键值对
如果my_dict不加任何方法，是遍历键；
加上my_dict.values()是遍历值；
加上my_dict.items()是遍历键值对，但是注意要有两个变量来接收。

for key in my_dict:
    print(key)

name
age
city

for value in my_dict.values():
    print (value)

ZhangSan
25
BeiJing

for item in my_dict.items():
    print(item)

('name', 'ZhangSan')
('age', 25)
('city', 'BeiJing')

字典的性质

字典的特性
    唯一性：键必须唯一，但值可以重复。
    无序性：字典在Python 3.7及更高版本中保持插入的顺序，但不应依赖此行为作为字典的普遍特性，因为字典本质上仍然是无序的。
    可变性：字典是可变的，可以添加、修改或删除键值对。
    
    特备注意！！！
    键的类型：字典的键是不可变的类型，可以是字符串、数字或元组，不能是列表或字典等可变类型。
    字典的值可以是可变的数据类型。

4.4、集合类型

4.4.1 集合

Python中集合是一个无序的、不包含重复元素的集合类型。
集合中的元素是唯一的，集合中不会出现两个相同的元素。

集合和字典的形式有相似之处，都是用{}引起来；
字典中是键值对，集合中是不重复的元素。

集合的创建

使用大括号 {} 包裹元素列表，元素之间用逗号分隔。
注意：此法不能创建空集合，因为那样创建出来的是空字典。

my_set = {1, 2, 3, 4}
print(my_set)

# 注意：以下创建的不是集合，而是字典
my_set_0 = {}

{1, 2, 3, 4}


使用 set() 函数，可把任何可迭代的对象（如列表、元组等）作为参数转换为一个集合。

# 把一个列表(或元组，元组不可变)转换成集合
my_set_list = set([1,2,3,4])
print(my_set_list)

# 把一个字典转换成集合
my_srt_dict = set({'name' : 'ZhangSan' , 'age' : '20'})
print(my_srt_dict) # 此时只会显示键而不显示值

{1, 2, 3, 4}
{'age', 'name'}

集合添加元素

用set.add()方法添加元素，如果元素已经存在则不会添加。

my_set.add(5)
print(my_set)

{1, 2, 3, 4, 5}

集合移除元素

有三种方法可以移除元素，分别是会报错、不会报错和随机弹出。
    remove()方法删除集合中的指定元素；若该元素不存在，会引发 KeyError。
    discard()方法也可以删除指定元素，若元素不存在，不会引发错误。
    pop()方法可以随机删除并返回。

my_set.remove(6)

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

~\AppData\Local\Temp\ipykernel_11720\1418257225.py in <module>
----> 1 my_set.remove(6)


KeyError: 6

my_set.discard(6)

print(my_set.pop())

判断元素是否存在

用in 可以判断元素是否存在在集合内。

if 1 in my_set:
    print("1存在！")
else:
    print("1不存在！")

1不存在！

集合运算

和数学上的集合类似，集合支持交、并、差的操作。
集合运算才是集合最常用的操作。
并集（| 或 union()）
交集（& 或 intersection()）
差集（- 或 difference()）
对称差集（^ 或 symmetric_difference()）等。

my_set_12345 = {1,2,3,4,5}
my_set_34567 = {3,4,5,6,7}

set_union = my_set_12345 | my_set_34567
print(set_union)

set_inter = my_set_12345 & my_set_34567
print(set_inter)

set_diff = my_set_12345 - my_set_34567
print(set_diff)

{1, 2, 3, 4, 5, 6, 7}
{3, 4, 5}
{1, 2}

用集合来去重

集合常用来去除列表中的重复元素。

# 原始列表，包含重复元素
old_list = [1, 2, 3, 4, 4, 5, 5, 6]

# 将列表转换为集合，自动去除重复元素
_set = set(old_list)

# 如果需要保留列表的形式（但顺序可能会改变）
_list = list(_set)

print("原始列表:", old_list)
print("去重后的集合:", _set)
print("去重后的列表:", _list)

原始列表: [1, 2, 3, 4, 4, 5, 5, 6]
去重后的集合: {1, 2, 3, 4, 5, 6}
去重后的列表: [1, 2, 3, 4, 5, 6]

old_list = [1,1,2,2,3,3,4,4,5,5,6,6]
# 如果直接把列表转成集合，再把集合转成列表，会失去原有的顺序
# 所以用for循环来保持原有的序列，需要一个空集合和空列表，这个算法可以记忆

# 创建一个空集合用于存储已见过的元素
_set = set()

# 创建一个新列表用于存储去重后的元素，同时保留顺序
unique_ordered_list = []

for i in old_list:
    if i not in _set:
        unique_ordered_list.append(i)
        _set.add(i)

print("原始列表:", old_list)
print("去重且保留顺序的列表:", unique_ordered_list)

原始列表: [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6]
去重且保留顺序的列表: [1, 2, 3, 4, 5, 6]

4.5、集合、字典、元组、列表的比较

列表list[]是最基本的数据结构；
元组tuple()和列表类似，只不过元组不可变；
字典dict{}是存键值对，主要用来索引；
集合set{}和字典都用{}，集合中是不重复的元素。

4.6 布尔类型

Python中布尔类型有两个，True和False，即真或假，表示逻辑上的真或假。
布尔类型广泛应用于条件判断、循环控制和逻辑运算。

4.6.1、布尔值的产生

直接通过Ture和False来创建

true = True
false = False

通过条件判断来产生

a = 3
b = 5
print(a>b)

False

布尔值与整型的转换

布尔类型可以隐式地转换为整型。

print(int(True))
print(int(False))

1
0


整型也可以转化为布尔型。

print(bool(1))
print(bool(0))
print(bool(-1))

True
False
True


非零的数值、非空的字符串、非空的列表等都被视为真（True）；
零、空字符串、空列表等则被视为假（False）。

4.6.2、布尔值与逻辑运算

Python中逻辑运算是对布尔值进行操作的运算，其结果也是布尔值。

与运算 and &&

print(True and True)
print(True and False)

True
False

或运算 or ||

print(True or False)
print(False or False)

True
False

非运算 not ！

print(not True)

False

模拟异或

Python中没有异或，可以通过与或非来模拟异或。
当两个相同的时候为真假，不同时为真。

# 这个函数可以记忆
def Xor(a,b):
    a = bool(a)
    b = bool(b)
    return (a and not b) or (not a and b)

1、开始写代码

1.1、 解释器和编辑器

1.2、Pycharm新建项目

1.3、Jupyter Nodebook新建项目

1.4、虚拟环境

Pycharm新建虚拟环境

Jupyter Notebook新建虚拟环境

1.5、print()函数详解

()中单双引号都可以

分隔符seq=’’ 结束符end=’’

转义字符 \n \t

打印列表list和字典dict

.format()填空占位符{}

f-string直接用{}引入变量名

2、math函数库

2.1 常数

2.2 算数运算

2.3 三角函数

2.4 对数函数

2.5 取整和舍入

2.6 其他函数

3、写注释

3.1 注释的作用

3.2 快捷键

4、数据类型

4.1 数字类型

4.1.1 整形

4.1.2 浮点型

浮点型和整型的互换

浮点型保留小数位数

4.2、序列类型

4.2.1、字符串

字符串的创建

字符串的索引和切片

字符串格式化

字符串的比较

字符串的迭代

字符串的方法和属性

4.2.2、列表

创建列表

访问元素

修改元素

添加元素

删除元素

列表遍历

列表推导式

列表嵌套

列表切片

列表的排序和反转

列表的合并和拆分

返回某值出现的次数

返回某值第一次出现的索引

4.2.3、元组

创建元组

元组的操作

不可变性带来的好处

4.2.4 范围对象

创建范围对象

在for循环中使用范围对象

4.3、映射类型

4.3.1、字典

字典的创建

访问字典元素

添加、删除字典元素

字典的遍历

字典的性质

4.4、集合类型

4.4.1 集合

集合的创建

集合添加元素

集合移除元素

判断元素是否存在

集合运算

用集合来去重

4.5、集合、字典、元组、列表的比较

4.6 布尔类型

4.6.1、布尔值的产生

直接通过Ture和False来创建

通过条件判断来产生

布尔值与整型的转换

1.1、解释器和编辑器