Python

注释

当行注释用#,多行注释用'''或""",三引号还可以作为方法的参数，用来保留字符串样式

# print("hello \nworld")

'''
for i in range(1, 11):
    print(f'第{i}个是{i}')
'''

"""
 for i in range(1, 11):
     print(f'第{i}个是{i}')
"""

print('''hello
    world''')

上面的代码会输出
hello
    world

变量

变量的定义,直接写变量名并且赋值
name = 'LiLei'
age = 20
var = 10
var = 'LeiLei'  #变量还可以赋值不同类型

常量

一般使用全部大写来定义常量名

is和==

    == 比较运算符  判断==左右两边的值是不是相等
    num = 1
    print(num == 1)

    is 判断对象的指向的地址是否相等，比较是否是同一个对象
    num = 1
    name = 'LeiLei'
    print(num is name)
    //False

在Python中，用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号。可使用反斜杠 \ 转义特殊字符。
每个（字符串），不夹杂空格或者特殊符号，默认开启intern机制，共享内存，靠引用计数决定是否销毁。相同的字符串默认只保留一份，当创建一个字符串，它会先检查内存里有没有这个字符串，如果有就不再创建新的了。
f-string:表示格式化的字符串，主要作用是简化了字符串格式化的过程，使得代码更加简洁和易读。
f-string 使用大写的'F'或者'f'作为字符串的前缀，然后在字符串中花括号{}来标记需要插入或替换的表达式。

for i in range(1, 11):
    print(f'第{i}个是{i}')

强制类型转换

num_int = 123
num_str = "456"
print("num_int 数据类型为:",type(num_int))
print("类型转换前，num_str 数据类型为:",type(num_str))
num_str = int(num_str) # 强制转换为整型
print("类型转换后，num_str 数据类型为:",type(num_str))
num_sum = num_int + num_str
print("num_int 与 num_str 相加结果为:",num_sum)
print("sum 数据类型为:",type(num_sum))
输出：
num_int 数据类型为: <class 'int'>
类型转换前，num_str 数据类型为: <class 'str'>
类型转换后，num_str 数据类型为: <class 'int'>
num_int 与 num_str 相加结果为: 579
sum 数据类型为: <class 'int'>

字符的编码和解码

str1 = '你好中国'
print(str1)
print(type(str1))

// 将字符串数据类型转换为字节型数据的过程成为编码 encode，需要指定编码类型
byte1 = str1.encode(encoding='utf8')
// 4个字符转换为了12个字节, 所以一个汉字占用3个字节
print(byte1) // b'\xe4\xbd\xa0\xe5\xa5\xbd\xe4\xb8\xad\xe5\x9b\xbd'
print(type(byte1))  // <class 'bytes'>

// 将字节型数据转换为字符型数据的过程称为解码 decode
str2 = byte1.decode(encoding='utf8')
print(str2) // 你好中国
print(type(str2)) // <class 'str'>

字符串占位符

//（1）字符串中使用 % 占位
int1 = 10
float1 = 3.14159
str1 = "int1 = %d, float1 = %f" % (int1, float1)
print(str1)
// int1 = 10, float1 = 3.141590

//（2）字符串.format()
int1 = 10
float1 = 3.14159
bool1 = True
str2 = "int1 = {}, float1 = {}, bool1 = {}".format(int1, float1, bool1)
print(str2)
// int1 = 10, float1 = 3.14159, bool1 = True

//设置参数
int1 = 10
float1 = 3.14159
bool1 = True
str2 = "int1 = {i1}, float1 = {f1}, bool1 = {b1}".format(i1=int1, f1=float1, b1=bool1)
print(str2)
// int1 = 10, float1 = 3.14159, bool1 = True

成员运算符

身份运算符

# -------------身份运算符---------------
m = 20
n = 20
q = 30
print(m is n) // True 判断m和n在内存中是否指向同一个地址
print(n is q) // False
print(n is not q) // True
# id() 用于获取对象在内存中的地址
print(id(m) == id(n)) # True

print("-" * 30)
# -------------is和==的区别---------------
a = [1,2,3]
b = a

print(b is a) // True
print(b == a) // True  比较地址中的内容是否相同

b = a[:]  //拷贝a列表中的数据到b列表中
print(b)
print(b is a) // False
print(b == a) // True

分支语句

if 表达式:
    语句1
else:
    语句2

if 表达式1:
    语句1
elif 表达式2:
    语句2
elif 表达式3:
    语句3
else: // else如不需要可以省略
    语句4

match 对象值:
    case 值1:
        语句1
    case 值2:
        语句2
    case _:
        匹配所有

//Python程序语言指定任何非0和非空（null）值为true，0 或者 null为false。
//if语句的判断条件可以用条件表达式来表示其关系，后面的:必须加。其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分表示同
//一范围，缩进取消后，就不在分支范围了。如果条件不成立，不执行语句块内容。

:= 赋值并返回结果运算法

    match ret := randint(0,15)
        case 1:
            print(f'随机数为{ret}')

三目运算符

表达式1 if 判断条件 else 表达式2

num1 = 2
num2 = 3
max_num = num1 if num1 > num2 else num2
print(max_num)

while循环

while 表达式:
 语句-循环体

rabbit = 2
week = 1
while week < 10:
 rabbit = rabbit + rabbit * 2
 week += 1
 print(f"第{week}周有{rabbit}只兔子")

//while 后可以加上 else，当 while 表达式结果为 False 时会执行 else 中的语句。

rabbit = 2
week = 1
while week < 10:
 rabbit = rabbit + rabbit * 2
 week += 1
else:
print(f"第{week}周有{rabbit}只兔子")
//此时else中代码，写在else中和写在循环外效果一样。else一般和 break一起使用，循环通过break终止后，else中的代码不会执行。

for循环

for循环
语法：
    for 临时变量 in 可迭代对象:
        循环体
    else:
        所有循环结束之后，执行的代码

list1 = [1,2,3,4,5,6,7,8,9]
print(list1)
for i in list1:
    print(i)

str1 = 'Hello World'
for i in str1:
    print(i,end=' ')

for i in range(1, 11):
    print(i)

循环相关的关键字

continue
    跳出当前正在进行的循环，继续下次循环
break
    跳出整个循环,不会执行循环的else分支
pass
    循环体或者的函数体的占位

列表

1) 通过索引获取列表中元素
list1 = [100, 200, 300, 400, 500]
print(list1[1]) // 200
print(list1[-2]) // 400
2) 列表切片
list1 = [100, 200, 300, 400, 500]
print(list1) // 取全部元素
print(list1[:]) // 复制整个列表
print(list1[2:4]) // 取索引从2开始到4(不包含)的元素
print(list1[2:]) // 取索引从2开始到末尾的元素
print(list1[:2]) // 取索引从0开始到2(不包含)的元素
print(list1[2:-1]) // 取索引从2开始到-1(不包含)的元素
print(list1[::-1]) // 倒序取元素

3) 向列表中添加元素
list1 = [100, 200, 300, 400, 500]
list1.append(600) # 在列表末尾追加元素
list1.insert(2,700) # 在列表指定的位置追加元素
print(list1)

4) 列表相加
list1 = [100, 200, 300]
list2 = ["a", "b", "c"]
print(list1 + list2) // [100, 200, 300, 'a', 'b', 'c']

5) 列表乘法
list1 = [100, 200, 300]
print(list1 * 2) // [100, 200, 300, 100, 200, 300]

6) 修改列表中元素
6.1 通过下标修改
list1 = [100, 200, 300, 400, 500]
list1[0] = -1
print(list1)

6.2 通过切片修改
list1 = [100, 200, 300, 400, 500]
list1[2:4] = ["a", "b", "c"]
print(list1)

7) 检查成员是否为列表中元素
list1 = [100, 200, 300]
print(100 in list1) // True

8)获取列表长度
list1 = [100, 200, 300]
print(len(list1)) // 3

9) 求列表中元素的最大值、最小值、加和
list1 = [100, 200, 300, 400, 500]
print(max(list1)) // 500
print(min(list1)) // 100
print(sum(list1)) // 1500

10) 遍历列表
10.1直接遍历列表元素
list1 = [100, 200, 300, 400, 500]
for i in list1:
  print(i)
10.2 通过下标遍历列表
list1 = [100, 200, 300, 400, 500]
for i in range(len(list1)):
  print(i, list1[i])
10.3 使用enumerate()同时获取列表的下标和元素
list1 = [100, 200, 300, 400, 500]
for i, val in enumerate(list1):
  print(i, val)

11) 删除列表指定位置元素或者切片
list1 = [100, 200, 300, 400, 500]
del list1[2]
print(list1)

12) 嵌套列表
列表中元素可以为列表。
list1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for inner_list in list1:
  print(inner_list)

13) 列表推导式
列表推导式是 Python 中一种简洁创建列表的方式，它将一个可迭代对象（如列表、元组、集合、字符串等）的元素通过某种运算或条件筛选后生成一个新的列表。
（1）基础的列表推导式
squares = [x**2 for x in range(5)]
print(squares) // [0, 1, 4, 9, 16]
（2）带条件的列表推导式
squares = [x**2 for x in range(10) if x % 2 == 0]
print(squares) // [0, 4, 16, 36, 64]
（3）使用现有列表的列表推导式
list1 = [1, 2, 3, 4, 5]
squares = [x**2 for x in list1]
print(squares) // [1, 4, 9, 16, 25]
（4）包含多个循环的列表推导式
list1 = [1, 2, 3, 4, 5]
list2 = ["a", "b", "c", "d", "e"]
tuple_list = [(i, j) for i in list1 for j in list2]
print(tuple_list)

14) zip()函数
zip() 函数可将多个可迭代对象中对应元素打包为一个个元组。
list1 = [1, 2, 3, 4, 5]
list2 = ["a", "b", "c", "d", "e"]
zipped = zip(list1, list2)
print(list(zipped))

元组

//元组是不可变的，不可以对元组中的元素进行修改
tuple1 = (100, 200, 300, 400, 500)
//元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
tuple1 = (100,)
//也可以通过元组推导式创建元组。
tuple_generator = (x for x in range(10)) // 获取生成器对象
print(tuple_generator)
tuple1 = tuple(tuple_generator) // 转换为元组
print(tuple1)

//访问元组
tuple1 = (100, 200, 300, 400, 500)
print(tuple1[2])
print(tuple1[-1])
print(tuple1[2:4])

//元组相加
tuple1 = (100, 200, 300)
tuple2 = ("a", "b", "c")
print(tuple1 + tuple2) // (100, 200, 300, 'a', 'b', 'c')

//元组乘法
tuple1 = (100, 200, 300)
print(tuple1 * 2) // (100, 200, 300, 100, 200, 300)

//检查成员是否为元组中元素
tuple1 = (100, 200, 300, 400, 500)
print(300 in tuple1) // True

//获取元组长度
tuple1 = (100, 200, 300, 400, 500)
print(len(tuple1)) // 5

//求元组中元素的最大值、最小值、加和
tuple1 = (100, 200, 300, 400, 500)
print(max(tuple1)) // 500
print(min(tuple1)) // 100
print(sum(tuple1)) // 1500

//遍历元组
tuple1 = (100, 200, 300, 400, 500)

for i in tuple1:
  print(i)

for i in range(len(tuple1)):
  print(i, tuple1[i])

for i, val in enumerate(tuple1):
  print(i, val)

//元组的不可变
元组的不可变指的是元组所指向的内存中的内容不可变，但可以重新赋值。
tuple1 = (100, 200, 300)
print(id(tuple1), tuple1)
tuple1 = tuple1 + (1, 2, 3)
print(id(tuple1), tuple1)
如果元组中元素是可变数据类型，其嵌套项可以被修改。
tuple1 = (100, 200, 300, [1, 2, 3])
tuple1[3].append(4)
print(tuple1) // (100, 200, 300, [1, 2, 3, 4])

集合Set

1. 创建集合
可以通过{}或set()创建集合，但创建空集合需要使用set()而非{}，因为{}会创建空字典。
set1 = {1, 2, 3}
set2 = set([1, 2, 3]) // 使用set()函数从列表创建集合
set3 = set()
print(set1, set2, set3)
也可以通过集合推导式创建集合。
set1 = {x for x in range(10) if x % 2 == 0}
print(set1) //{0, 2, 4, 6, 8}

2. 向集合中添加元素
set1 = {1, 2, 3}
set1.add(4)
set1.add(5)
print(set1)

3. 从集合中删除元素
set1 = {1, 2, 3}
set1.remove(2)
print(set1)

4. 检查成员是否为集合中元素
set1 = {1, 2, 3, 4, 5}
print(2 in set1) // True

5. 获取集合长度
set1 = {1, 2, 3, 4, 5}
print(len(set1)) // 5

6. 求集合中元素的最大值、最小值、加和
set1 = {1, 2, 3, 4, 5}
print(max(set1)) // 5
print(min(set1)) // 1
print(sum(set1)) // 15

7. 遍历集合
my_set = {1, 2, 3, 4, 5}
for item in my_set:
 print(item)

字典Dict

1. 创建字典
//可以通过{}或dict()创建字典。
dict1 = {}
dict2 = dict()
dict3 = {"name": "Alice", "age": 18, "gender": "male"}
dict4 = dict(name="Bob", age=20, gender="female")
dict5 = dict([("name", "Tom"), ("age", 22), ("gender", "male")])
print(dict1)
print(dict2)
print(dict3)
print(dict4)
print(dict5)
//也可以通过字典推导式创建字典。
squares = {x: x**2 for x in range(4)}
print(squares) // {0: 0, 1: 1, 2: 4, 3: 9}

2. 访问字典
//可通过 [] 访问字典中的元素。key不存在时会报错。
dict1 = {"name": "Alice", "age": 18, "gender": "male"}
print(dict1["name"]) // Alice
print(dict1["age"]) // 18
print(dict1["gender"]) // male
print(dict1["address"]) // 报错
//也可以通过get()获取字典中的元素。key不存在时会返回None，也可以指定默认值。
dict1 = {"name": "Alice", "age": 18, "gender": "male"}
print(dict1.get("name")) // Alice
print(dict1.get("age")) // 18
print(dict1.get("gender")) // male
print(dict1.get("address")) // None
print(dict1.get("address", "earth")) // earth

3. 向字典中添加元素
//为字典指定的key赋值value，若key原本不存在则会被添加。
dict1 = {"name": "Alice", "age": 18, "gender": "male"}
dict1["address"] = "earth"
print(dict1)

4. 修改字典中元素
//通过key修改对应的value。
dict1 = {"name": "Alice", "age": 18, "gender": "male"}
dict1["name"] = "Bob"
print(dict1)

5. 检查成员是否为字典中的key
dict1 = {"name": "Alice", "age": 81, "gender": "male"}
print("name" in dict1) // 检查key是否存在
print("Alice" in dict1) // 无法直接检查value是否存在

6. 获取字典长度
dict1 = {"name": "Alice", "age": 81, "gender": "male"}
print(len(dict1)) // 3

7.遍历字典
my_dict = {'Name': 'Tom', 'Age': 17}

# 遍历出所有k
keys = my_dict.keys()
for k in keys:
  print (k)
print("-" *20)
# 遍历出所有v
vals = my_dict.values()
print(vals)
for v in vals:
  print (v)
print("-" *20)
# k-v遍历
keys = my_dict.keys()
for k in keys:
  print (k + "---" + str(my_dict[k]))
print("-" *20)
kv = my_dict.items()
for i in kv:
  print(i)

8.删除字典元素
my_dict = {'Name': 'Tom', 'Age': 17}
del my_dict['Name'] # 删除键 'Name'
my_dict.clear() //  清空字典
del my_dict // 删除字典

print (my_dict)

函数

Python 定义函数使用 def 关键字，一般格式如下：
def 函数名 (参数列表) :
     函数体
     [return]

不定长参数
参数的个数是不确定的。
（1）语法：
def 函数名([普通参数,] *var_args_tuple ):
    函数体

def 函数名([普通参数,] **var_args_dict ):
    函数体
加了两个星号 ** 的参数会以字典的形式导入，后面就不能再有其他参数了
'''
     该案例演示了函数调用时的不定长参数
'''
def printInfo(num,**vardict):
    print(num)
    print(vardict)
    # return

printInfo(10,key1 = 20,key2 = 30)
printInfo(10,a = 20,b = 30)

解包传参
若函数的形参是定长参数，可以通过 * 和 ** 对列表、元组、字典等解包传参。
def func(a, b, c):
    return a + b + c

tuple11 = (1, 2, 3)
print(func(*tuple11))
# 字典中key的名称和参数名必须一致
dict1 = {"a": 1, "b": 2, "c": 3}
print(func(**dict1))

强制使用位置参数或关键字参数
/ 前的参数必须使用位置传参，* 后的参数必须用关键字传参。
def f(a, b, /, c, d, *, e, f):
     print(a, b, c, d, e, f)

f(1, 2, 3, d=4, e=5, f=6)

防止函数修改列表
有时要函数对列表进行处理，又不希望函数修改原列表，copy.copy()浅拷贝，可以使用 copy.deepcopy()深拷贝
import copy

def multiply2(var1):
 var1[3].append(400)
 print("函数内处理后：", var1)

list1 = [1, 2, 3, [100, 200, 300]]
print("函数外处理前：", list1)
multiply2(copy.deepcopy(list1))
print("函数外处理后：", list1)

返回值
在程序开发中，有时候希望一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理。返回值就是函数完成工作后，给调用者的一个结果
在函数中使用 return 关键字可以返回结果 ，并结束正在执行的函数
如果return后面跟[表达式]，在结束函数的同时向调用方返回一个表达式。
如果仅仅是return关键字，后面没有加内容，函数执行返回调用方None。
调用函数一方，可以使用变量来接收函数的返回结果
（1）不带表达式的 return 语句，返回 None。
def f(a, b, c):
 pass
 return

print(f(1, 2, 3)) // None
（2）函数中如果没有 return 语句，在函数运行结束后也会返回 None。
def f(a, b, c):
 pass

print(f(1, 2, 3)) // None
（3）用变量接收返回结果
def add(num1,num2) :
 '''求两个数的和'''
 sum1 = num1 + num2
 return sum1

res = add(10,20)
print("两个数的和为:" ,res)
（4）return 语句可以返回多个值，多个值会放在一个元组中。
def f(a, b, c):
 return a, b, c, [a, b, c]
print(f(1, 2, 3)) // (1, 2, 3, [1, 2, 3])

变量作用域

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问，如下代码：

# 分支,循环不会引入新的作用域
num = 2
if num > 1:
  msg = "helloWorld"
print(msg)

def test():
  msg_test = "welcome"
print(msg_test)

var1 = 100
def function_a():
  global var1  //函数内使用 global 声明全局变量后，可以修改全局变量。
  var1 = 200
  print("var1:", var1)

//当全局变量为可变类型时，函数内不使用 global 声明，也可以对其进行修改。
list1 = [1, 2, 3]

def function_a():
  list1[0] = -1000
  print("list1:", list1)

//nonlocal 也用作内部作用域修改外部作用域的变量的场景，不过此时外部作用域不是全局作用域而是嵌套作用域。

def function_outer():
  var1 = 1
  print(var1)
  def function_inner():
    nonlocal var1
    var1 = 200
  function_inner()
  print(var1)
function_outer() # var1: 1 -> 200