python

​ Python由荷兰数学和计算机科学研究学会的吉多·范罗苏姆于1990年代初设计，作为一门叫做ABC语言的替代品。 Python提供了高效的高级数据结构，还能简单有效地面向对象编程。Python语法和动态类型，以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的编程语言， 随着版本的不断更新和语言新功能的添加，逐渐被用于独立的、大型项目的开发。

vscode环境配置

安装miniconda

miniconda基本使用：

操作	命令	说明
查看所有环境	conda env list	当前已有的环境列表，带 * 号的是当前激活的环境。
创建新环境	conda create -n 环境名 python=版本号	例如：conda create -n data_analysis python=3.9。
激活环境	conda activate 环境名	激活后，命令行前面会出现 (环境名)，此时安装的包都会在这个环境里。
退出环境	conda deactivate	退出当前环境，回到基础环境。
删除环境	conda remove -n 环境名 --all	彻底删除某个不用的环境。

conda进行包管理：

功能分类	命令示例	作用说明
🔍 查找与查看	conda list	最常用：列出当前环境中已安装的所有包及其版本。
	conda search <包名>	在仓库中搜索包，查看有哪些版本可用（例如：conda search pandas）。
	conda list <包名>	只查看某个特定的包是否已安装及其版本。
⬇️ 安装与下载	conda install <包名>	最常用：在当前激活的环境中安装指定包（例如：conda install numpy）。
	conda install <包名>=<版本号>	安装指定版本的包（例如：conda install tensorflow=2.6.0），用于复现旧项目。
	conda install <包名1> <包名2>	同时安装多个包，Conda 会自动解决它们之间的依赖关系。
	conda install -c conda-forge <包名>	从指定的通道（Channel）安装包。如果官方源找不到包，通常去 conda-forge 社区源找。
	conda install -n <环境名> <包名>	给未激活的指定环境安装包（不用切来切去，很方便）。
⬆️ 更新与升级	conda update <包名>	将某个包更新到当前 Python 版本兼容的最新版本。
	conda update --all	更新当前环境中所有可更新的包（慎用，可能会导致版本冲突）。
	conda update conda	更新 Conda 工具本身（建议在 base 环境下执行）。
🗑️ 卸载与清理	conda remove <包名>	卸载当前环境中的指定包。
	conda remove <包名> --all	卸载指定包及其依赖它的其他包。
	conda clean --all	强力推荐：清理下载缓存和无用的包文件，释放磁盘空间（定期执行）。
📝 导出与复现	conda env export > environment.yml	将当前环境的配置导出为 yml 文件，方便分享给别人或备份。
	conda env create -f environment.yml	根据导出的 yml 文件，一键重建一个一模一样的环境。

注释

注释以 ＃ 开头，Python 将忽略它们：

#This is a comment
print("Hello, World!")

print("Hello, World!") #This is a comment

多行注释

#This is a comment
#written in
#more than just one line
print("Hello, World!")

三引号多行注释

"""
This is a comment
written in 
more than just one line
"""
print("Hello, World!")

变量

变量的命名规则：

• 变量名必须以字母或下划线字符开头
• 变量名称不能以数字开头
• 变量名只能包含字母数字字符和下划线（A-z、0-9 和 _）
• 变量名称区分大小写（age、Age 和 AGE 是三个不同的变量）

创建变量

变量是存放数据值的容器。

与其他编程语言不同，Python 没有声明变量的命令。

首次为其赋值时，才会创建变量。

x = 10
y = "Bill"
print(x)
print(y)

向多个变量赋值

x, y, z = "Orange", "Banana", "Cherry"
print(x)
print(y)
print(z)

可以在一行中为多个变量分配相同的值：

x = y = z = "Orange"
print(x)
print(y)
print(z)

全局变量

在函数外部创建的变量（如上述所有实例所示）称为全局变量。

全局变量可以被函数内部和外部的每个人使用。

在函数外部创建变量，并在函数内部使用它：

x = "awesome"

def myfunc():
  print("Python is " + x)

myfunc()

global 关键字

通常，在函数内部创建变量时，该变量是局部变量，只能在该函数内部使用。

要在函数内部创建全局变量，可以使用 global 关键字。

如果用了 global 关键字，则该变量属于全局范围：

def myfunc():
  global x
  x = "fantastic"

myfunc()

print("Python is " + x)

如果要在函数内部更改全局变量，请使用 global 关键字。

要在函数内部更改全局变量的值，使用 global 关键字引用该变量：

x = "awesome"

def myfunc():
  global x
  x = "fantastic"

myfunc()

print("Python is " + x)

数据类型

Number（数字）

Python 中有三种数字类型：

• int
• float
• complex

为变量赋值时，将创建数值类型的变量：

x = 10   # int
y = 6.3  # float
z = 2j   # complex

Int

Int 或整数是完整的数字，正数或负数，没有小数，长度不限。

Float

浮动或“浮点数”是包含小数的正数或负数。

x = 3.50
y = 2.0
z = -63.78

print(type(x))
print(type(y))
print(type(z))

#科学计数法
x = 27e4
y = 15E2
z = -49.8e100

复数

复数用 “j” 作为虚部编写：

x = 2+3j
y = 7j
z = -7j

print(type(x))
print(type(y))
print(type(z))

类型转换

可以使用 int()、float() 和 complex() 方法从一种类型转换为另一种类型：

从一种类型转换为另一种类型：

x = 10 # int
y = 6.3 # float
z = 1j # complex

# 把整数转换为浮点数

a = float(x)

# 把浮点数转换为整数

b = int(y)

# 把整数转换为复数：

c = complex(x)

print(a)
print(b)
print(c)

print(type(a))
print(type(b))
print(type(c))

随机数

Python 没有 random() 函数来创建随机数，但 Python 有一个名为 random 的内置模块，可用于生成随机数：

导入 random 模块，并显示 1 到 9 之间的随机数：

import random

print(random.randrange(1,10))

---

String（字符串）

字符串字面量

python 中的字符串字面量由单引号或双引号括起。

'hello' 等同于 "hello"。

多行字符串

可以使用三个引号将多行字符串赋值给变量：

a = """Python is a widely used general-purpose, high level programming language. 
It was initially designed by Guido van Rossum in 1991 
and developed by Python Software Foundation. 
It was mainly developed for emphasis on code readability, 
and its syntax allows programmers to express concepts in fewer lines of code."""
print(a)

字符串是数组

像许多其他流行的编程语言一样，Python 中的字符串是表示 unicode 字符的字节数组。

但是，Python 没有字符数据类型，单个字符就是长度为 1 的字符串。

方括号可用于访问字符串的元素。

获取位置 1 处的字符（请记住第一个字符的位置为 0）：

a = "Hello, World!"
print(a[1])

字符串裁切

可以使用裁切语法返回一定范围的字符。

指定开始索引和结束索引，以冒号分隔，以返回字符串的一部分。（前闭后开）使用负索引从字符串末尾开始切片

获取从位置 2 到位置 5（不包括）的字符：

b = "Hello, World!"
print(b[2:5])

字符串长度

a = "Hello, World!"
print(len(a))

字符串方法

strip() 方法删除开头和结尾的空白字符：

a = " Hello, World! "
print(a.strip()) # returns "Hello, World!"

lower() 返回小写的字符串：

a = "Hello, World!"
print(a.lower())

upper() 方法返回大写的字符串：

a = "Hello, World!"
print(a.upper())

replace() 用另一段字符串来替换字符串：

a = "Hello, World!"
print(a.replace("World", "Kitty"))

split() 方法在找到分隔符的实例时将字符串拆分为子字符串：

a = "Hello, World!"
print(a.split(",")) # returns ['Hello', ' World!']

检查字符串方法

in``not in

txt = "China is a great country"
x = "ina" in txt
print(x)

txt = "China is a great country"
x = "ain" not in txt
print(x) 

字符串级联（串联）

使用+

将变量 a 与变量 b 合并到变量 c 中：

a = "Hello"
b = "World"
c = a + b
print(c)

字符串格式

不能直接组合字符串和数字：

age = 19
txt = "My name is Bill, I am " + age
print(txt) #error

可以使用 format() 方法组合字符串和数字！

format() 方法接受传递的参数，格式化它们，并将它们放在占位符 {} 所在的字符串中：

使用 format() 方法将数字插入字符串：

age = 63 
txt = "My name is Bill, and I am {}"
print(txt.format(age))

format() 方法接受不限数量的参数，并放在各自的占位符中：

quantity = 3
itemno = 567
price = 49.95
myorder = "I want {} pieces of item {} for {} dollars."
print(myorder.format(quantity, itemno, price))

可以使用索引号 {0} 来确保参数被放在正确的占位符中：

quantity = 3
itemno = 567
price = 49.95
myorder = "I want to pay {2} dollars for {0} pieces of item {1}."
print(myorder.format(quantity, itemno, price))

字符串方法

所有字符串方法都返回新值。它们不会更改原始字符串。

频率	方法	实战描述与典型场景
⭐⭐⭐⭐⭐	split()	数据清洗必备。将字符串按分隔符切分为列表（如处理CSV行、解析URL参数）。
⭐⭐⭐⭐⭐	strip()	输入处理必备。去除首尾空格或换行符（如处理用户输入、读取文件行）。
⭐⭐⭐⭐⭐	replace()	文本修正必备。替换指定子串（如敏感词过滤、路径修正）。
⭐⭐⭐⭐⭐	lower() / upper()	标准化必备。统一转为小写或大写（如比对用户名、密码、验证码时忽略大小写）。
⭐⭐⭐⭐⭐	in / not in	逻辑判断必备。检查子串是否存在（如 if "error" in log:）。
⭐⭐⭐⭐	join()	拼接必备。将列表高效合并为字符串（如生成SQL语句、拼接路径）。
⭐⭐⭐⭐	count()	统计必备。统计子串出现次数（如词频统计）。
⭐⭐⭐⭐	startswith() / endswith()	路由与过滤必备。判断文件后缀（如 .csv）或URL前缀（如 /api）。
⭐⭐⭐⭐	find()	查找必备。查找子串位置，找不到返回-1（比index更安全，不会报错）。
⭐⭐⭐	format()	模板化必备。格式化字符串（虽然现在流行 f-string，但 format 在复杂模板中仍常用）。
⭐⭐⭐	index()	定位必备。查找子串位置，找不到会报错（需配合 try-except 使用）。
⭐⭐⭐	isdigit()	校验必备。判断是否全为数字（如校验金额、ID）。
⭐⭐⭐	isalnum()	校验必备。判断是否仅含字母和数字（如校验用户名、密码强度）。
⭐⭐⭐	lstrip() / rstrip()	精细清洗。分别去除左侧或右侧空白（如处理缩进代码块）。
⭐⭐	encode() / decode()	编码处理。处理字节流与字符串转换（如处理网络请求、文件读写编码）。
⭐⭐	title() / capitalize()	格式化。首字母大写（如生成报表标题、人名标准化）。
⭐⭐	center() / ljust() / rjust()	排版。文本对齐填充（如打印控制台表格、生成固定宽度日志）。
⭐⭐	partition()	拆分。将字符串分为“前-中-后”三部分（比split更适合只切一刀的场景）。

---

bool（布尔）

大多数值都为 True

如果有某种内容，则几乎所有值都将评估为 True。

除空字符串外，任何字符串均为 True。

除 0 外，任何数字均为 True。

除空列表外，任何列表、元组、集合和字典均为 True

某些值为 False

实际上，除空值（例如 ()、[]、{}、""、数字 0 和值 None）外，没有多少值会被评估为 False。当然，值 False 的计算结果为 False。

下例会返回 False：

bool(False)
bool(None)
bool(0)
bool("")
bool(())
bool([])
bool({})

---

List（列表）

Python 编程语言中有四种集合数据类型：

• 列表（List）是一种有序和可更改的集合。允许重复的成员。
• 元组（Tuple）是一种有序且不可更改的集合。允许重复的成员。
• 集合（Set）是一个无序和无索引的集合。没有重复的成员。
• 词典（Dictionary）是一个无序，可变和有索引的集合。没有重复的成员。

选择集合类型时，了解该类型的属性很有用。

为特定数据集选择正确的类型可能意味着保留含义，并且可能意味着提高效率或安全性。

list1 = ['Google', 'Runoob', 1997, 2000]

列表索引

insert()在列表中插入元素

删除元素：

• del()直接删除，不做任何用处
• pop()默认删除列表尾部元素，传递删除元素
• remove()以关键字删除元素

下标修改列表中元素，访问元素

排序：

• sort()永久排序
• sorted()暂时排序
• reverse()永久翻转列表

list = [i*2 for i in range(1,11)]列表解析（创建10以内数的平方）

切片：

• list[0:3]前三个元素

• list[-3:0]最后三个元素

• list_copy = list[:]复制元素（待补充：python的赋值原理）

复制列表

只能通过键入 list2 = list1 来复制列表，因为：list2 将只是对 list1 的引用，list1 中所做的更改也将自动在 list2 中进行。

有一些方法可以进行复制，一种方法是使用内置的 List 方法 copy()。

使用 copy() 方法来复制列表：

thislist = ["apple", "banana", "cherry"]
mylist = thislist.copy()
print(mylist)

制作副本的另一种方法是使用内建的方法 list()。

使用 list() 方法复制列表：

thislist = ["apple", "banana", "cherry"]
mylist = list(thislist)
print(mylist)

合并两个列表

在 Python 中，有几种方法可以连接或串联两个或多个列表。

最简单的方法之一是使用 + 运算符。

合并两个列表：

list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

list3 = list1 + list2
print(list3)

连接两个列表的另一种方法是将 list2 中的所有项一个接一个地追加到 list1 中：

把 list2 追加到 list1 中：

list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

for x in list2:
  list1.append(x)

print(list1)

或者，可以使用 extend() 方法，其目的是将一个列表中的元素添加到另一列表中：

使用 extend() 方法将 list2 添加到 list1 的末尾：

list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

list1.extend(list2)
print(list1)

list() 构造函数

也可以使用 list() 构造函数创建一个新列表。

使用 list() 构造函数创建列表：

thislist = list(("apple", "banana", "cherry")) # 注意双括号
print(thislist)

列表方法

方法	描述
append()	在列表的末尾添加一个元素
clear()	删除列表中的所有元素
copy()	返回列表的副本
count()	返回具有指定值的元素数量。
extend()	将列表元素（或任何可迭代的元素）添加到当前列表的末尾
index()	返回具有指定值的第一个元素的索引
insert()	在指定位置添加元素
pop()	删除指定位置的元素
remove()	删除具有指定值的项目
reverse()	颠倒列表的顺序
sort()	对列表进行排序

---

Tuple（元组）

元组是有序且不可更改的集合。在 Python 中，元组是用圆括号编写的。

tup = ('Google', 'Runoob', 1997, 2000)
#定义只含一个元素的元组
one_thing = (1,)

• 元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用

• 访问：元组可以相list一样通过下标访问

• 修改：元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

• 删除：元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

• 截取：元组同样可以通过[:]方法来截取

合并两个元组

如需连接两个或多个元组，可以使用 + 运算符：

合并这个元组：

tuple1 = ("a", "b" , "c")
tuple2 = (1, 2, 3)

tuple3 = tuple1 + tuple2
print(tuple3)

tuple() 构造函数

也可以使用 tuple() 构造函数来创建元组。

使用 tuple() 方法来创建元组：

thistuple = tuple(("apple", "banana", "cherry")) # 请注意双括号
print(thistuple)

删除整个元组

del tup #删除整个元组 

元组方法

Python 提供两个可以在元组上使用的内建方法。

方法	描述
count()	返回元组中指定值出现的次数。
index()	在元组中搜索指定的值并返回它被找到的位置。

---

Set（集合）

集合是无序和无索引的集合。在 Python 中，集合用花括号编写。

parame = {value01,value02,...}
或者
set(value)

• 添加：add()
• 移除：remove()
• 清空：clear()

s.add(x) #添加，如果元素已经存在，不进行任何操作
s.update(x) #同样是添加元素

s.remove(x) #元素不存在发生错误
s.discard(x) #删除，不存在不会法生错误

访问项目

无法通过引用索引来访问 set 中的项目，因为 set 是无序的，项目没有索引。

但是可以使用 for 循环遍历 set 项目，或者使用 in 关键字查询集合中是否存在指定值。

遍历集合，并打印值：

thisset = {"apple", "banana", "cherry"}

for x in thisset:
  print(x)

更改项目

集合一旦创建，就无法更改项目，但是可以添加新项目。

合并两个集合

在 Python 中，有几种方法可以连接两个或多个集合。

可以使用 union() 方法返回包含两个集合中所有项目的新集合，也可以使用 update() 方法将一个集合中的所有项目插入另一个集合中：

union() 方法返回一个新集合，其中包含两个集合中的所有项目：

set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}

set3 = set1.union(set2)
print(set3)

set() 构造函数

也可以使用 set() 构造函数来创建集合。

使用 set() 构造函数来创建集合：

thisset = set(("apple", "banana", "cherry")) # 请留意这个双括号
print(thisset)

集合函数

Set 方法

Python 拥有一套能够在集合（set）上使用的内建方法。

方法	描述
add()	向集合添加元素。
clear()	删除集合中的所有元素。
copy()	返回集合的副本。
difference()	返回包含两个或更多集合之间差异的集合。
difference_update()	删除此集合中也包含在另一个指定集合中的项目。
discard()	删除指定项目。
intersection()	返回为两个其他集合的交集的集合。
intersection_update()	删除此集合中不存在于其他指定集合中的项目。
isdisjoint()	返回两个集合是否有交集。
issubset()	返回另一个集合是否包含此集合。
issuperset()	返回此集合是否包含另一个集合。
pop()	从集合中删除一个元素。
remove()	删除指定元素。
symmetric_difference()	返回具有两组集合的对称差集的集合。
symmetric_difference_update()	插入此集合和另一个集合的对称差集。
union()	返回包含集合并集的集合。
update()	用此集合和其他集合的并集来更新集合。

---

Dictionary（字典）

字典是一个无序、可变和有索引的集合。在 Python 中，字典用花括号编写，拥有键和值。

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

# 添加
dic = {} # 创建一个空字典
dic['first'] = '1'

# 修改键值对中的值
dic['first'] = '一' #以关键字来访问

# 删除键值对

del dic['first'] #以关键字来访问删除

#删除指定键名的项
thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
thisdict.pop("model")


# 遍历字典
## 遍历字典键值对
for key,value in dic.items()

## 遍历所有的键
for key in dic.keys()

## 遍历所有值
for value in dic.values()

#clear() 关键字清空字典：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
thisdict.clear()

复制字典

不能通过键入 dict2 = dict1 来复制字典，因为：dict2 只是对 dict1 的引用，而 dict1 中的更改也将自动在 dict2 中进行。

有一些方法可以进行复制，一种方法是使用内建的字典方法 copy()。

使用 copy() 方法来复制字典：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
mydict = thisdict.copy()
print(mydict)

#使用 dict() 方法创建字典的副本：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
mydict = dict(thisdict)
print(mydict)

嵌套字典

词典也可以包含许多词典，这被称为嵌套词典。

创建包含三个字典的字典：

myfamily = {
  "child1" : {
    "name" : "Phoebe Adele",
    "year" : 2002
  },
  "child2" : {
    "name" : "Jennifer Katharine",
    "year" : 1996
  },
  "child3" : {
    "name" : "Rory John",
    "year" : 1999
  }
}

dict() 构造函数

也可以使用 dict() 构造函数创建新的字典：

thisdict = dict(brand="Porsche", model="911", year=1963)
# 请注意，关键字不是字符串字面量
# 请注意，使用了等号而不是冒号来赋值
print(thisdict)

字典方法

Python 提供一组可以在字典上使用的内建方法。

方法	描述
clear()	删除字典中的所有元素
copy()	返回字典的副本
fromkeys()	返回拥有指定键和值的字典
get()	返回指定键的值
items()	返回包含每个键值对的元组的列表
keys()	返回包含字典键的列表
pop()	删除拥有指定键的元素
popitem()	删除最后插入的键值对
setdefault()	返回指定键的值。如果该键不存在，则插入具有指定值的键。
update()	使用指定的键值对字典进行更新
values()	返回字典中所有值的列表

---

Python 运算符

运算符用于对变量和值执行操作。

Python 在以下组中划分运算符：

• 算术运算符
• 赋值运算符
• 比较运算符
• 逻辑运算符
• 身份运算符
• 成员运算符
• 位运算符

Python 算术运算符

算术运算符与数值一起使用来执行常见的数学运算：

运算符	名称	实例
+	加	x + y
-	减	x - y
*	乘	x * y
/	除	x / y
%	取模	x % y
**	幂	x ** y
//	地板除（取整除）	x // y

Python 赋值运算符

赋值运算符用于为变量赋值：

运算符	实例	等同于
=	x = 5	x = 5
+=	x += 3	x = x + 3
-=	x -= 3	x = x - 3
*=	x *= 3	x = x * 3
/=	x /= 3	x = x / 3
%=	x %= 3	x = x % 3
//=	x //= 3	x = x // 3
**=	x **= 3	x = x ** 3
&=	x &= 3	x = x & 3
|=	x |= 3	x = x | 3
^=	x ^= 3	x = x ^ 3
>>=	x >>= 3	x = x >> 3
<<=	x <<= 3	x = x << 3

Python 比较运算符

比较运算符用于比较两个值：

运算符	名称	实例
==	等于	x == y
!=	不等于	x != y
>	大于	x > y
<	小于	x < y
>=	大于或等于	x >= y
<=	小于或等于	x <= y

Python 逻辑运算符

逻辑运算符用于组合条件语句：

运算符	描述	实例
and	如果两个语句都为真，则返回 True。	x > 3 and x < 10
or	如果其中一个语句为真，则返回 True。	x > 3 or x < 4
not	反转结果，如果结果为 true，则返回 False	not(x > 3 and x < 10)

Python 身份运算符

身份运算符用于比较对象，不是比较它们是否相等，但如果它们实际上是同一个对象，则具有相同的内存位置：

运算符	描述	实例
is	如果两个变量是同一个对象，则返回 true。	x is y
is not	如果两个变量不是同一个对象，则返回 true。	x is not y

Python 成员运算符

成员资格运算符用于测试序列是否在对象中出现：

运算符	描述	实例
in	如果对象中存在具有指定值的序列，则返回 True。	x in y
not in	如果对象中不存在具有指定值的序列，则返回 True。	x not in y

逻辑结构

条件控制（if）

if

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

match case

match subject:
    case <pattern_1>:
        <action_1>
    case <pattern_2>:
        <action_2>
    case <pattern_3>:
        <action_3>
    case _:
        <action_wildcard>

case

mystatus=400
print(http_error(400))

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the internet"

---

循环语句（while for）

while

while 判断条件(condition)：
    执行语句(statements)……

经典用例

# 列表之间移动元素
sandwich_orders = ['rose','lily','maria']

finished_sandwichs = []

while sandwich_orders:
    concurrent_sandwich = sandwich_orders.pop()
    print(f'I make your {concurrent_sandwich}')
    finished_sandwichs.append(concurrent_sandwich)
print(f'we have finieshed {finished_sandwichs}')

#删除特定元素
pets =  ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
print(pets)
while 'cat' in pets:
    pets.remove('cat')
print(pets)

#填充字典
qa = {}
flag = True
print(type(flag))

while flag:
    name = input('whats your name?')
    place = input('where would want to go someday?')
    qa[name] = place
    repeat = input('would want to talk more?(Yes/No) ')
    if repeat == 'No':
        flag = False

print(qa)

for

for <variable> in <sequence>:
    <statements>
else:
    <statements>

range()

>>>for i in range(5): #打印（0，5）
...     print(i)

>>>for i in range(5,9) : #前开后闭
    print(i)

break continue

pass

>>>while True:
...     pass  # 等待键盘中断 (Ctrl+C)

python推导式

列表推导式

[表达式 for 变量 in 列表 if 条件]

res = [x for x in range(1,10) if x%2==0] #迭代偶数列表
print(res)

 [2, 4, 6, 8]

---

字典推导式

{ key_expr: value_expr for value in collection if condition }

listdemo = ['Google','Runoob', 'Taobao']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
>>> newdict = {key:len(key) for key in listdemo}
>>> newdict
{'Google': 6, 'Runoob': 6, 'Taobao': 6}

---

集合推导式

{ expression for item in Sequence if conditional }

>>> setnew = {i**2 for i in (1,2,3)}
>>> setnew
{1, 4, 9}

---

元组推导式

(expression for item in Sequence if conditional )

>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器对象

>>> tuple(a)       # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)

---

迭代器和生成器

15分钟彻底搞懂迭代器、可迭代对象、生成器【python迭代器】_哔哩哔哩_bilibili

迭代器

#迭代器类型的定义
 1.当类中定义了_iter和_next_两个方法
 2._iter_方法需要返回对象本身，即self
 3._next_方法，返回下一个数据，如果没有数据了，即要抛出一个StopIteration的异常

 #创建迭代器类型
	class IT(object):
        def _init_(self):
			self.count = 0
            
    	def _iter_(self):
            return self
        
        def _next_(self):
            self.count+=1
            if self.count==3:
                raise StopIteration()
            return self.count
        
 #根据类实例创建一个迭代器对象
	obj1 = IT()
    
    v1 = obj._next_()#执行类中的函数
    
    v1 = next(obj1)#相当于执行上个代码
    
    obj2 = IT()
    for item in obj2: #首先会执行迭代对象的_iter_方法并获取返回值，一直区反复执行next（对象）,每执行一次将返回值传递给item
        print(item)
        
#迭代器对象支持通过next取值，如果取值结束则自动抛出StopIteration
#for循环内部循环时候，先执行_iter_方法，获取一个迭代器对象，然后不断执行next取值

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。

# 创建生成器函数
 def func():
        yield 1
        yield 2
        
#创建生成器对象（内部是更具生成器类generator创建的对象），生成器类的内部也声明了:__iter__,__next__方法

	obj1= func()
    
    for item in obj1:
        print(item)
        
        
#如果迭代器的规定来看，其实生成器也是一种特殊的迭代器类（生成器是一种特殊的迭代器）

可迭代对象

#创建迭代器类型
class IT(object):
       def _init_(self):
		self.count = 0
           
   	def _iter_(self):
           return self
       
       def _next_(self):
           self.count+=1
           if self.count==3:
               raise StopIteration()
           return self.count
  class Foo(object):
  		def __iter__(self):
           return IT()     #返回迭代器对象
   
   obj =　Foo() #可迭代对象
   
   for item in obj:  #循环可迭代对象时候，内部限制性obj.__iter__并获取迭代器对象，不断执行迭代对象的__next__方法
       print(item)

#基于可迭代对象和迭代器实现：自定义range
class IterRange(object):
    def __init__(self,num):
        self.num = num
        self.counter = -1
        
     def __iter__(self):
        return self
    
    self __next__(self):
        self.counter += 1
        if self.counter ==self.num；
			raise StopIteration()
        return self.counter
    
    
class Xrange(object):
    def __inint__(self,max_num):
        self.max_num = max_num
        
    def __iter__(self.max_num)
    
obj = Xrange(100)

for item in obj:
    print(item)

python函数

函数是组织好的，可以重复使用的，用来实现单一，或者先关联功能的代码段。函数能提高应用的模块性，和代码的重复使用率。python已经提供了很多的内建函数，如print()函数。用户也可以自己创建函数，这个叫用户自定义函数。

语法

def greet_user(username):
    """显示简单的问候语。"""
    print(f"Hello, {username.title()}!")
greet_user('jesse')

参数

信息可以作为参数传递给函数。

参数在函数名后的括号内指定。可以根据需要添加任意数量的参数，只需用逗号分隔即可。

下面的例子有一个带参数（fname）的函数。当调用此函数时，我们传递一个名字，在函数内部使用它来打印全名：

def my_function(fname):
  print(fname + " Gates")

my_function("Bill")
my_function("Steve")
my_function("Elon")

默认参数值

def my_function(country = "China"):
  print("I am from " + country)

my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")

以List传参

发送到函数的参数可以是任何数据类型（字符串、数字、列表、字典等），并且在函数内其将被视为相同数据类型。

例如，如果将 List 作为参数发送，它到达函数时仍将是 List（列表）：

def my_function(food):
  for x in food:
    print(x)

fruits = ["apple", "banana", "cherry"]

my_function(fruits)

关键字参数

还可以使用 key = value 语法发送参数。

参数的顺序无关紧要。

def my_function(child3, child2, child1):
  print("The youngest child is " + child3)

my_function(child1 = "Phoebe", child2 = "Jennifer", child3 = "Rory")

任意参数

如果不知道将传递给的函数多少个参数，在函数定义的参数名称前添加 *。

这样，函数将接收一个参数元组，并可以相应地访问各项：

def my_function(*kids):
  print("The youngest child is " + kids[2])

my_function("Phoebe", "Jennifer", "Rory")

返回值

如需使函数返回值，请使用 return 语句：

def my_function(x):
  return 5 * x

print(my_function(3))
print(my_function(5))
print(my_function(9))

匿名函数

Python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

lambda [arg1 [,arg2,.....argn]]:expression

python面向对象

python类/对象

创建类

如需创建类，请使用 class 关键字：

使用名为 x 的属性，创建一个名为 MyClass 的类：

class MyClass:
  x = 5

创建对象

以使用名为 myClass 的类来创建对象：

创建一个名为 p1 的对象，并打印 x 的值：

p1 = MyClass()
print(p1.x)

init() 函数

上面的例子是最简单形式的类和对象，在实际应用程序中并不真正有用。

要理解类的含义，我们必须先了解内置的 __init__() 函数。

所有类都有一个名为 __init__() 的函数，它始终在启动类时执行。

使用 __init__() 函数将值赋给对象属性，或者在创建对象时需要执行的其他操作：

创建名为 Person 的类，使用 __init__() 函数为 name 和 age 赋值：

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

p1 = Person("Bill", 63)

print(p1.name)
print(p1.age)

每次使用类创建新对象时，都会自动调用 __init__() 函数。

对象方法

对象也可以包含方法。对象中的方法是属于该对象的函数。

在 Person 类中创建方法：

插入一个打印问候语的函数，并在 p1 对象上执行它：

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

  def myfunc(self):
    print("Hello my name is " + self.name)

p1 = Person("Bill", 63)
p1.myfunc()

self 参数

self 参数是对类的当前实例的引用，用于访问属于该类的变量。

它不必被命名为 self，可以随意调用它，但它必须是类中任意函数的首个参数：

使用单词 mysillyobject 和 abc 代替 self：

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

  def myfunc(abc):
    print("Hello my name is " + abc.name)

p1 = Person("Bill", 63)
p1.myfunc()

python 继承

继承允许我们定义继承另一个类的所有方法和属性的类。

父类是继承的类，也称为基类。

子类是从另一个类继承的类，也称为派生类。

创建父类

任何类都可以是父类，因此语法与创建任何其他类相同：

创建一个名为 Person 的类，其中包含 firstname 和 lastname 属性以及 printname 方法：

class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

# 使用 Person 来创建对象，然后执行 printname 方法：

x = Person("Bill", "Gates")
x.printname()

创建子类

要创建从其他类继承功能的类，请在创建子类时将父类作为参数发送：

创建一个名为 Student 的类，它将从 Person 类继承属性和方法：

class Student(Person):
  pass

现在，Student 类拥有与 Person 类相同的属性和方法。

使用 Student 类创建一个对象，然后执行 printname 方法：

x = Student("Elon", "Musk")
x.printname()

添加 init() 函数

到目前为止，已经创建了一个子类，它继承了父类的属性和方法。

想要把 __init__() 函数添加到子类（而不是 pass 关键字）。

为 Student 类添加 __init__() 函数：

class Student(Person):
  def __init__(self, fname, lname):
    # 添加属性等       加 __init__() 函数时，子类将不再继承父的 __init__() 函数。

子的 __init__() 函数会覆盖对父的 __init__() 函数的继承。

如需保持父的 __init__() 函数的继承，添加对父的 __init__() 函数的调用：

class Student(Person):
  def __init__(self, fname, lname):
    Person.__init__(self, fname, lname)

使用 super() 函数

Python 还有一个 super() 函数，它会使子类从其父继承所有方法和属性：

class Student(Person):
  def __init__(self, fname, lname):
    super().__init__(fname, lname)

python多态

“多态”（polymorphism）一词意为“多种形式”，在编程中，它指的是可以在许多对象或类上执行的具有相同名称的方法/函数/操作符。

函数多态

一个可用于不同对象的 Python 函数的例子是 len() 函数。

字符串

对于字符串，len() 返回字符数：

x = "Hello World!"

print(len(x))

元组

对于元组，len() 返回元组中的项目数：

mytuple = ("apple", "banana", "cherry")

print(len(mytuple))

字典

对于字典，len() 返回字典中的键值对数量：

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}

print(len(thisdict))

类多态

多态经常在类方法中使用，我们可以在其中有多个具有相同方法名的类。

例如，假设我们有三个类：Car、Boat 和 Plane，并且它们都有一个名为 move() 的方法：

有相同方法的不同类：

class Car:
  def __init__(self, brand, model):
    self.brand = brand
    self.model = model

  def move(self):
    print("Drive!")

class Boat:
  def __init__(self, brand, model):
    self.brand = brand
    self.model = model

  def move(self):
    print("Sail!")

class Plane:
  def __init__(self, brand, model):
    self.brand = brand
    self.model = model

  def move(self):
    print("Fly!")

car1 = Car("Ford", "Mustang")       #Create a Car class
boat1 = Boat("Ibiza", "Touring 20") #Create a Boat class
plane1 = Plane("Boeing", "747")     #Create a Plane class

for x in (car1, boat1, plane1):
  x.move()

继承类多态

如果使用上面的例子并创建一个名为 Vehicle 的父类，并使 Car、Boat、Plane 成为 Vehicle 的子类，则子类将继承 Vehicle 的方法，但可以覆盖它们：

创建一个名为 Vehicle 的类，并使 Car、Boat、Plane 成为 Vehicle 的子类：

class Vehicle:
  def __init__(self, brand, model):
    self.brand = brand
    self.model = model

  def move(self):
    print("Move!")

class Car(Vehicle):
  pass

class Boat(Vehicle):
  def move(self):
    print("Sail!")

class Plane(Vehicle):
  def move(self):
    print("Fly!")

car1 = Car("Ford", "Mustang") # 创建 Car 对象
boat1 = Boat("Ibiza", "Touring 20") # 创建 Boat 对象
plane1 = Plane("Boeing", "747") # 创建 Plane 对象

for x in (car1, boat1, plane1):
  print(x.brand)
  print(x.model)
  x.move()

python作用域

局部作用域

在函数内部创建的变量属于该函数的局部作用域，并且只能在该函数内部使用。

def myfunc():
  x = 100
  print(x)

myfunc()

函数内部的函数

如上例中所示，变量 x 在函数外部不可用，但对于函数内部的任何函数均可用：

def myfunc():
  x = 100
  def myinnerfunc():
    print(x)
  myinnerfunc()

myfunc()

全局作用域

在 Python 代码主体中创建的变量是全局变量，属于全局作用域。

全局变量在任何范围（全局和局部）中可用。

x = 100

def myfunc():
  print(x)

myfunc()

print(x)

Global 关键字

如果要创建一个全局变量，但被卡在本地作用域内，则可以使用 global 关键字。

global 关键字使变量成为全局变量。

如果使用 global 关键字，则该变量属于全局范围：

def myfunc():
  global x
  x = 100

myfunc()

print(x)

另外，如果要在函数内部更改全局变量，也请使用 global 关键字。

x = 100

def myfunc():
  global x
  x = 200

myfunc()

print(x)

python模块

模块是包含一组函数的文件，希望在应用程序中引用。

创建模块

如需创建模块，只需将所需代码保存在文件扩展名为 .py 的文件中：

在名为 mymodule.py 的文件中保存代码：

def greeting(name):
  print("Hello, " + name)

使用模块

现在，就可以用 import 语句来使用我们刚刚创建的模块：

导入名为 mymodule 的模块，并调用 greeting 函数：

import mymodule

mymodule.greeting("Bill")

模块中的变量

模块可以包含已经描述的函数，但也可以包含各种类型的变量（数组、字典、对象等）：

在文件 mymodule.py 中保存代码：

person1 = {
  "name": "Bill",
  "age": 63,
  "country": "USA"
}

导入名为 mymodule 的模块，并访问 person1 字典：

import mymodule

a = mymodule.person1["age"]
print(a)

重命名模块

可以在导入模块时使用 as 关键字创建别名：

为 mymodule 创建别名 mx：

import mymodule as mx

a = mx.person1["age"]
print(a)

内建模块

Python 中有几个内建模块，可以随时导入。

导入并使用 platform 模块：

import platform

x = platform.system()
print(x)

使用 dir() 函数

有一个内置函数可以列出模块中的所有函数名（或变量名）。dir() 函数：

列出属于 platform 模块的所有已定义名称：

import platform

x = dir(platform)
print(x)

从模块导入

可以使用 from 关键字选择仅从模块导入部件。

名为 mymodule 的模块拥有一个函数和一个字典：

def greeting(name):
  print("Hello, " + name)

person1 = {
  "name": "Bill",
  "age": 63,
  "country": "USA"
}

仅从模块导入 person1 字典：

from mymodule import person1

print (person1["age"])

python字符串格式化

字符串 format()

format() 方法允许格式化字符串的选定部分。

添加要显示价格的占位符：

price = 52
txt = "The price is {} dollars"
print(txt.format(price))

可以在花括号内添加参数以指定如何转换值：

将价格格式化为带有两位小数的数字：

txt = "The price is {:.2f} dollars"

多个值

如需使用更多值，只需向 format() 方法添加更多值：

print(txt.format(price, itemno, count))

并添加更多占位符：

quantity = 3
itemno = 567
price = 52
myorder = "I want {} pieces of item number {} for {:.2f} dollars."
print(myorder.format(quantity, itemno, price))

索引号

可以使用索引号（花括号 {0} 内的数字）来确保将值放在正确的占位符中：

quantity = 3
itemno = 567
price = 52
myorder = "I want {0} pieces of item number {1} for {2:.2f} dollars."
print(myorder.format(quantity, itemno, price))

此外，如果要多次引用相同的值，请使用索引号：

age = 63
name = "Bill"
txt = "His name is {1}. {1} is {0} years old."
print(txt.format(age, name))

命名索引

还可以通过在花括号 {carname} 中输入名称来使用命名索引，但是在传递参数值 txt.format(carname = “Ford”) 时，必须使用名称：

myorder = "I have a {carname}, it is a {model}."
print(myorder.format(carname = "Porsche", model = "911"))