# Python的禅
import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

print("Hello World!")

Hello World!

print(1) # 打印整数
print(3.9) # 打印浮点数
print('a') # 打印字符
print("string") # 打印字符串
print(3 + 5) # 打印表达式的值
print(print) # 打印函数信息
"""
  可以同时打印多个对象，用逗号隔开
  可以使用sep和end参数来修改多个对象之间的间隔符和打印完成后的结束符  
"""
print(5, '666')
print(1, 2, 3, 4, sep='-', end=';')
print(666)

1
3.9
a
string
8
<built-in function print>
5 666
1-2-3-4;666

import keyword

keywords = keyword.kwlist
print(keywords) # 使用keyword模块来查看Python中所有的关键字

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

a = 5
print(type(a))
a = 6.9
print(type(a))
a = "web"
print(type(a))

<class 'int'>
<class 'float'>
<class 'str'>

a = 1   # '='符号表示赋值
print(a)
a = -5  # 负整数也是整数
print(a)
b = 2*10**400 + 10  # 一个星号表示乘法运算符，两个星号表示次方运算符，运算次序和算术中的规则相同
print(b)
c = 2**10240
print(c)

1
-5
20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010
35249714121083826571348148398002815464391421343966471060391382605731070276854749365048330296473663862456968155395298373973259049475943113619888338673116133666814706870765271907656205646018608369985558721267670321739031938633833281889192620158426531806923144239269726876399951961191980348023291703472305763782410394589758934585631111078120435303032688818751446435291371357171755632775362932694795076313436687469638004327689390246735321855830610856865924913760826763776003265851716557334210642277343475757799780499021559822412434275087084317293455129570406707590002071704673135527533543217355987568107697577946785796412456048360072965616871024866244650081059068183038134518514222987186837394598019859512993600379236190197576838905080733359989094687008999416247722020061992559931401872357379708488585003666965930609730430774107407494018065365845077094320534700692354400169824131578389153656916754682252425562742895026822086112236185768931940433324078692386463642378029291582384550904012284265277124667452816985659337497580991592510201479766500877427834566619156314388107585743546289067551052434075678195345373363919571323210113622615511765134329627207955793605376892875938357672870881305679305521293359975427801921997534891474090868113467357784359783383091085717100807228425031226776985197364359404683041506613943646666199454899363685801848776729685837803228216113833854742443409221480450232563130417709625320794971672737737385983975520047739978165124906916857931960902407397841536657650378758012409157205939513085324282439290108909069036515430690359963152986587749930516880670326145036987607052961696781556418550966201822821857978020062536824015697620957222738065538832187097409859502669196589025961199448758997373792973191723335549772394878874050854532785922475822836403793986623193174020931432381418437022760412682276382989354839625453241289807108260905134234679130954867570447354549760174691007078528452745027994943853229480544512368831378761119681616719327637308142315105120528704683515182038320225078665313911731749364255621284434304945437214609406008640520972029509955435568094888815701470419410889156523971182172814423274140955428070594328381667048286771972857703435525803544707834567774027206614143419982410109261930698311010857874866840743851472857645330929169548403751084494725893729355450473771059986801058342021902735367627900974872368137838996397379898161454825970910732858202781282973937642847973381838672980693399039429342613001595148968082010016061022316242842367672741265405434553107296623559604413326352140529618171175450657884255099334618722731697920185582437182391397673301168160682516639214706566981465961731374808949131742364752993078326367714117001404210930251538132442219335072672096865184691303027156962439777053707286583949764055151291816402546462452719134797179099210233577596277925646031824172274874084562113440043397395191065473620717104250686040896580928700842593919173283844531470952205600874482302488523867074532907781264990865351844684807012208039108287564534854500486391538876063611476665620230294811468351835374072060530215907909311281816131942219776

a = 3.14
print(a)
a = -3.141592653589793
print(a)
a = round(a, 4) # 使用内置函数round()来获得指定精度的浮点数
print(a)

b = 1.0000000000000000000000000000000000000000000000000000000000000000012
print(b)

x = 0.1
y = 0.2
print(x + y) # 需要注意浮点数运算时可能产生的微小误差

3.14
-3.141592653589793
-3.1416
1.0
0.30000000000000004

a = 3 + 4j
print(a)
print(abs(a)) # 求复数的模长

(3+4j)
5.0

print(1+1 == 2)
print(1+1 != 3)
print(3.11 > 3.8)
print({1, 3} < {1, 3, 5})

a=1
b=2
print(a==b)
print(2*a==b)

True
True
False
True
False
True

print("Hello World!")
print('Hello\nWorld!')
print('Hello\tWorld!')
print(r'Hello\nWorld!')
print("I am printing 'Hello World!'")
print('I am printing "Hello World!"')

# 字符串里面可以是任意字符
print("兴隆山技术工程工作站web开发部")

Hello World!
Hello
World!
Hello	World!
Hello\nWorld!
I am printing 'Hello World!'
I am printing "Hello World!"
兴隆山技术工程工作站web开发部

pound = 9
penny = 15
option = 'c'
print(f"衬衫的价格是{pound}磅{penny}便士，所以你选择{option.upper()}选项")

衬衫的价格是9磅15便士，所以你选择C选项

a='你好世界'
print(a)
print(type(a))
b=a.encode('GB2312')
print(b)
print(type(b))
c=b.decode('GB2312')
print(c, end='       ')
print('c == a is', c==a);print('======目前为止还很正常对吧======');print('下面是一些奇怪的东西：')
c=b.decode('utf-8', 'replace')
print(c)
d=c.encode('utf-8').decode('GB2312', 'replace')
print(d)

你好世界
<class 'str'>
b'\xc4\xe3\xba\xc3\xca\xc0\xbd\xe7'
<class 'bytes'>
你好世界       c == a is True
======目前为止还很正常对吧======
下面是一些奇怪的东西：
�������
锟斤拷锟斤拷锟斤拷锟�

a = [] # 定义一个空列表
b = list() # 这也是定义一个空列表
print(a, b)
c = [1, 2, 3]
print(c[0], c[-1])
c[1] = 9
print(c)

l1 = [[1, 2], ['a', 'b'], [3.4, "list"], [int, float, complex]]
print(l1)

[] []
1 3
[1, 9, 3]
[[1, 2], ['a', 'b'], [3.4, 'list'], [<class 'int'>, <class 'float'>, <class 'complex'>]]

a = [3]
a.append(4)
print(a)
a.extend([5, 6, 7])
print(a)
removed_num = a.pop()
print(a, removed_num)
removed_num = a.pop(-2)
print(a, removed_num)
a.remove(3)
print(a)

a.insert(0, 2)
print(a)

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

a = [1.6, 2.4, 3, 0, 7.9]
print(len(a))

print(1 in [1, 2, 3], 4 in [1, 2, 3])

5
True False

l1 = [i for i in range(100)]
print(l1)

print(l1[20:50:2])
print(l1[50:20:-2])
print(l1[80:])
print(l1[:20])
print(l1[::-1]) # start参数缺失则从第一个元素开始，end参数如果到最后一个元素结束，step参数如果缺失则为1

print(l1[150:200]) # 如果切片范围超出列表索引范围，不会报错，只会得到一个空列表
l1[1:4] = [101, 102, 103] # 切片还可以赋值
print(l1)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
[20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48]
[50, 48, 46, 44, 42, 40, 38, 36, 34, 32, 30, 28, 26, 24, 22]
[80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
[99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
[]
[0, 101, 102, 103, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

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

a = '1,2,3'
b = a.split(',')
print(b)

c = '-'.join(b)
print(c)

ell
['1', '2', '3']
1-2-3

a = () # 定义一个空元组
b = tuple() # 这也是定义一个空元组
print(a, b)

"""
需要注意，如果用()来定义一个只含有一个元素的元组，那么在这个元素的后面必须加一个逗号
Python依靠这个逗号将其与普通括号区分
"""
x = (1)
t1 = (1,) 
print(type(x), x)
print(type(t1), t1)

() ()
<class 'int'> 1
<class 'tuple'> (1,)

a = set() # 需要注意的是空集合只能这样定义
b = {} # 用{}定义的不是空集合，而是空字典
print(a, type(a))
print(b, type(b))

c = {1, 2, 3} # 非空集合可以用{}来定义
c.add(4)
print(c)
d = {1, 3, 5, 7} 
d.remove(5)
print(d)

print(c & d)
print(c | d)
print(c - d)
print(c ^ d)

e = {'a', 'b', 'c'}
e.update({'b', 'c', 'd', 'e', 'F'}) # update智能地更新集合的元素
print(e)

s1 = {[1, 2], {1, 3}}  # 试图以列表作为集合元素，会产生TypeError错误

set() <class 'set'>
{} <class 'dict'>
{1, 2, 3, 4}
{1, 3, 7}
{1, 3}
{1, 2, 3, 4, 7}
{2, 4}
{2, 4, 7}
{'e', 'F', 'b', 'c', 'd', 'a'}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[20], line 22
     19 e.update({'b', 'c', 'd', 'e', 'F'}) # update智能地更新集合的元素
     20 print(e)
---> 22 s1 = {[1, 2], {1, 3}}  # 试图以列表作为集合元素，会产生TypeError错误

TypeError: unhashable type: 'list'

a = {} # 定义一个空字典
b = dict() # 这也是定义一个空字典
print(a, type(a))
print(b, type(b))

d1 = {'a':1, 'b':2, 'c':3}  # 用大括号按固定格式定义字典
print(d1)

d2 = dict(year=2024, month=11, day=1, weather='sunny')  # 用关键字参数定义字典，注意此时键只能为字符串且不加引号
print(d2)

print(d1.keys())  # 返回一个包含字典中的所有键的视图对象
print(d1.values())  # 返回一个包含字典中的所有值的视图对象
print(d1.items())   # 返回一个包含字典中的所有键值对的视图对象，其中每一组键值对以元组的形式呈现

# 由items()方法引申出来的一种字典定义方法：将若干个键值对元组构成的列表转换为dict类型
d3 = dict([('id', 666), ('username', 'Tom')])
print(d3)

d4 = {'Alice':{'age': 23, 'gender': 'female'}}  # 值也可以是字典（字典的嵌套）
print(d4)

print(d1['b'])  # 通过键来获取对应的值
d1['c'] = 5   # 通过键来修改对应的值
print(d1)
d1['d'] = 9   # 给不存在的键赋值会将该键值对加入字典中
print(d1)


d1.update({'a':2, 'd': 15})
print(d1)

print(d1.get('b', 99))
print(d1.get('z', 99))  # 试图获取不存在键的值，此时会返回给定值99

{} <class 'dict'>
{} <class 'dict'>
{'a': 1, 'b': 2, 'c': 3}
{'year': 2024, 'month': 11, 'day': 1, 'weather': 'sunny'}
dict_keys(['a', 'b', 'c'])
dict_values([1, 2, 3])
dict_items([('a', 1), ('b', 2), ('c', 3)])
{'id': 666, 'username': 'Tom'}
{'Alice': {'age': 23, 'gender': 'female'}}
2
{'a': 1, 'b': 2, 'c': 5}
{'a': 1, 'b': 2, 'c': 5, 'd': 9}
{'a': 2, 'b': 2, 'c': 5, 'd': 15}
2
99

l1 = ['A', 'B', 'C', 'B', 'A', 'C', 'A']
d1 = {}

for item in l1:
    d1[item] = d1.get(item, 0) + 1

print(d1)

{'A': 3, 'B': 2, 'C': 2}

a = None
print(a)

None

d1 = {'a':6, 'b':7}
print(type(d1.keys()))
print(type(d1.values()))
print(type(d1.items()))

def square(x):
  return x * x
print(type(square))

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

stu1 = Student('Robot')
print(type(Student))
print(type(stu1))

<class 'dict_keys'>
<class 'dict_values'>
<class 'dict_items'>
<class 'function'>
<class 'type'>
<class '__main__.Student'>

a = [1, 2, 3, 2]
b = tuple(a)
print(b)
c = list(b)
print(c)
d = set(c)  # 将其他元素可重复的对象转换成集合时会自动“合并同类项”，利用这个特性可以进行元素去重
print(d)
e = dict(a=6)
print(e)

s1 = '114514'
n1 = int(s1)
print(n1)

n2 = 3.14159265
s2 = str(n2)
print(s2, type(s2))
n3 = int(3.9)  # float->int会舍去小数
print(n3)

(1, 2, 3, 2)
[1, 2, 3, 2]
{1, 2, 3}
{'a': 6}
114514
3.14159265 <class 'str'>
3
5.0

l1 = [1, 2, 3]  # 现在我们定义一个列表
l2 = l1   # 将l1的内容赋给新变量l2

l2[2] = 4   # 改变l2中下标为2的元素
print(f'l1={l1}, l2={l2}')  # 发现l1[2]的值也变了，为啥？

l1=[1, 2, 4], l2=[1, 2, 4]

a = 5 # 当我们定义一个变量a=5时，Python 会在电脑中寻找一块内存，把5写入这块内存，然后将a指向这块内存。
print(id(a)) 
a = 6 # 当我们将a的值改成6时，Python 会开辟一块新的内存，然后把6写入这块内存，接着让a转而指向这块内存。
print(id(a))
b = 6 # 定义一个同样为6的变量b，你会发现b指向的内存和a是同一块。
print(id(b))
print(a is b)   # 事实上，a和b就是引用同一个对象的不同“别名”
a = 5
print(id(a))    # 把a改回5，发现其指回了之前那一块内存，其中的内容没有变化，仍然是5

140727755916200
140727755916232
140727755916232
True
140727755916200

a = 5
b = a   # 将a的值赋给b，他们将指向同一块内存
print(a is b)
b = 6   # 接着改变b的值，b的指向改变，而a不受影响
print(f'a={a}, b={b}')

True
a=5, b=6
140727755916200 140727755916232

l1 = [1, 2]
print(id(l1))
l1.append(6)
l1[1] = 3   # 修改列表变量中的元素，其地址不变
print(id(l1))

2375939027392
2375939027392

l1 = ['a', ['b', 'c', 'd'], ['e', 'f']]
l2 = l1     # l2是对l1的引用，实际上相当于给l1起了一个叫l2的别名，因此l1和l2完全是同一个对象。
print(l2 is l1)
l1.append(4) 
l2.append(5)
print(l1, l2)   # 不管是对l1还是l2操作其实是在操作同一个对象

l1 = ['a', ['b', 'c', 'd'], ['e', 'f']]
l2 = l1.copy()  # list内置的copy()方法，仅对第一层为深拷贝，其他层均为浅拷贝
print(l2 is l1) # 可以发现拷贝得到的列表对象的地址和原列表不一样了
print(l1[1] is l2[1])   # 但是其中嵌套的列表依然在同一块内存中，如果修改l1中嵌套的列表，则l2中的对应值也会改变

l2 = l1[:] # 全默认值切片的方法，也是仅对第一层为深拷贝，其他层均为浅拷贝

l2 = []
for i in l1:
    l2.append(i)    # for循环拷贝法，也是仅对第一层为深拷贝，其他层均为浅拷贝

import copy
l2 = copy.copy(l1)  # 使用copy模块中的copy()方法，还是仅对第一层为深拷贝，其他层均为浅拷贝


l2 = copy.deepcopy(l1)  # 使用copy模块中的deepcopy()方法，对所有层均为深拷贝
l2[0] = 'g'
l2[1][0] = 'f'      # 不管修改新列表中哪一层的元素，都不会对旧列表造成影响
print(f'l1={l1}, l2={l2}')

True
['a', ['b', 'c', 'd'], ['e', 'f'], 4, 5] ['a', ['b', 'c', 'd'], ['e', 'f'], 4, 5]
False
True
l1=['a', ['b', 'c', 'd'], ['e', 'f']], l2=['g', ['f', 'c', 'd'], ['e', 'f']]

# 加号
a = 3 + 4   # 数字的算术和
b = [1, 2] + [3, 4, 5]  # 列表的拼接
c = (1, 2) + (3, 4, 5)  # 元组的拼接
d = 'py' + 'thon'   # 字符串的拼接
# 集合和字典不支持加法运算符  
print(a, b, c, d)

# 减号
a = 3 - 4   # 数字的算术差
b = {1, 2} - {1, 3}  # 集合求差集
print(a, b)

7 [1, 2, 3, 4, 5] (1, 2, 3, 4, 5) python
-1 {2}

# 乘号
a = 3 * 4   # 数字的算术积
b = [1, 2] * 3     # 将列表中的元素的复制成三份（元组和字符串也可以）
c = [[1]] * 3   # 需要注意，如果列表中的元素是列表，那么这样复制的话其中的所有子列表都是同一个对象
c[0].append(2)
print(a, b, c)
print(id(c[0]), id(c[1]), id(c[2]))

# 对容器进行解包
s1 = 'python'   # 对字符串解包，得到其中的所有元素
l1 = [1, 2, 3]  # 对列表解包，得到其中的所有元素
t1 = (1, 2, 3)  # 对元组解包，得到其中的所有元素
set1 = {1, 2, 3}    # 对集合解包，得到其中的所有元素
d1 = {'a':1, 'b':2} # 对字典直接解包，得到的是所有的键
print(*s1)
print(*l1)
print(*t1)
print(*d1)

12 [1, 2, 1, 2, 1, 2] [[1, 2], [1, 2], [1, 2]]
1189223684608 1189223684608 1189223684608
p y t h o n
1 2 3
1 2 3
a b

# 除号
a = 3/4     # 真除法，得到的结果为商的精确值且为浮点型
b = 3//4    # 整除法，得到的结果是商的整数部分
print(a, b)

# 取余号
c = 15%4    # 19/4=4···3
print(c)
d = -15%4   # -19/4=-5···1  说明余数只取非负数
print(d)

0.75 0
3
1

# 比较运算符，得到的结果为Bool类型True/False
a = 5
print(4<a<6)    # 在Python 中支持连续比较，等价于 a>4 and a<6
b = 5
c = 5
print(a==b==c)  # 等价于a==b and b==c

# 使用不同的比较运算符连续比较也是被允许的，但是这样写可读性很差，不建议使用
print(6>a<7)    # 等价于a<6 and a<7

True
True
True

# 成员运算符，得到的结果为Bool类型True/False
print(3 in [1, 2, 3])
print('d' in 'Hello World!')
print('a' in {'a':1, 'b':2})    # 如果in后面是字典，则只会判断前面的元素是否为字典的键
print(2 in {'a':1, 'b':2})

print(3 not in {4, 5})
# 注意in后面的对象必须是可迭代的，或者说能包含多个元素的类型，比如列表，元组，集合，字典等

True
True
True
False
True

# 逻辑运算符，具有惰性求值特点
# 首先需要知道的是，对于逻辑运算来说，参与的元素只有True和False两种，并且只有0相当于False，其他所有值都相当于True

print(not 5)    # not表示逻辑非，会将True的东西转换为False，将False的东西转换为True
print(not 0)

# and表示逻辑与，就是我们通常所说的“且”，连接的两个表达式均为True时整个表达式才为True，否则为False
print('a' and 5)  # 当and之前的表达式值为True时，整个表达式的值为and之后的表达式的值
print(0 and 6)    # 当and之前的表达式值为False时，整个表达式的值为and之前的表达式的值

# or表示逻辑或，连接的两个表达式均为False时整个表达式才为False，否则为True
print(0 or [1, 2, 3])  # 当or之前的表达式值为False时，整个表达式的值为or之后的表达式的值
print(0 or False)
print(7 or 5)           # 当or之前的表达式值为True时，整个表达式的值为or之前的表达式的值

False
True
5
0
[1, 2, 3]
False
7

# 赋值运算符
a = 5   # 给变量赋值
b = a

a += 3  # 变量自身加3
b = b + 3   # 和上式结果一样，但实现过程不同。不同在哪呢？在不可变类型上看不出来，我们用可变类型的对象试试

l1 = [1, 2]
print(id(l1))
l1 += [3]
print(l1,id(l1))        # 用+=符号赋值，是改变对象自身的值。

l2 = [1, 2]
print(id(l2))
l2 = l2 + [3]           # 用=符号赋值，是创建了一个新的对象
print(l2,id(l2))

# 其余算术运算也可有赋值符号，如-=,*=,/=,%=

1307121602176
[1, 2, 3] 1307121602176
1307121597120
[1, 2, 3] 1307120987712

a, b = 10, 20   # 同时分别给a和b赋值
print(a, b)

a, b = b, a   # 无需中间变量直接交换a和b的值
print(a, b)

a, b = (6, 7)   # 将序列中的元素依此赋给a和b，需要保证序列中元素的数量和变量的数量一致
print(a, b)
a, b, *c = [1, 2, 3, 4, 5]  # 将序列中的前两个元素赋值给a和b，将剩余的元素以列表形式赋值给c，需要使用*解包运算符
print(a, b, c)
a, b, *c = (1, 2, 3, 4, 5)  # 虽然原序列为元组，但是剩余的元素依然以列表形式赋值给c
print(a, b, c) 

# 将序列中的前三个元素赋值给a、b和c，将最后一个元素赋值给d，剩余元素以列表形式赋给c
a, b, *c, d = (1, 2, 3, 4, 5, 6) 
print(a, b, c, d)

10 20
20 10
6 7
1 2 [3, 4, 5]
1 2 [3, 4, 5]
1 2 [3, 4, 5] 6

a=input('请输入：')   # 读取输入的内容，转换为字符串

if a=='1':
    print('a is 1')
elif a.isnumeric():  # isnumeric是str内置函数，判断字符串里的内容是否是数字
    print('a is a number, but not 1')
else:
    print('a is not a number')

a is a number, but not 1

a = -5
if a > 0:
    print("a is positive")
else:
    print("a is not positive")
    print("error!")
    print("Please give a positive number")
print("End of program")

a is not positive
error!
Please give a positive number
End of program

a = 5
b = 7
max_num = a if a > b else b     # 相当于C语言中的a>b?a:b
print(max_num)

7

a = 20
while a > 0:    # while后面跟一个表达式，当表达式为True时，循环继续执行，当表达式为False时，循环结束。
    print("上学哪有不疯的，硬撑罢了！")
    a -= 1

上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！
上学哪有不疯的，硬撑罢了！

a = [1,2,3,4,5,6,7,8,9,10]
while a:        # while后面跟一个可迭代序列，可以进行遍历
    print(a.pop(),end=' ')
print(a)

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

a=[1,2,3,4,5,6,7,8,9,10]
for i in a:     # 对于在列表a中的每一个元素i，执行以下语句
    print(i, end=' ')
print(a)

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

a={'a':1, 'b':2, 'c':3, 'd':4, 'e':0}
# 遍历字典的时候可以使用我们之前提到过的几种方法来处理不同的需求。
for i in a:
    print(i, end=' ')
print()
for i in a.keys():
    print(i, end=' ')
print()
for i in a.values():
    print(i, end=' ')
print()
for key, value in a.items():    # 如果每次遍历得到的对象是序列，可以分别获取其中的所有元素
    print(key, value, end=' ')
print()
for i in a.items():
    print(i , end=' ')
print()   
a, b = (1, 2)
print(a, b)

a b c d e 
a b c d e 
1 2 3 4 0 
a 1 b 2 c 3 d 4 e 0 
('a', 1) ('b', 2) ('c', 3) ('d', 4) ('e', 0) 
1 2

for i in range(10):     # 只给一个参数，则认为给的值为终止值，起始值为0，步长为1
    print(i, end=' ')
print()

for i in range(10, 20):  # 给两个参数，则认为给的第一个值为起始值，第二个值为终止值，步长为1
    print(i, end=' ')
print()

for i in range(-20, 100, 15):  # 给三个参数，则认为给的第一个值为起始值，第二个值为终止值，第三个值为步长4
    print(i, end=' ')
print()

for i in range(15, 5, -2):  # 步长可以为负
    print(i, end=' ')
print()

0 1 2 3 4 5 6 7 8 9 
10 11 12 13 14 15 16 17 18 19 
-20 -5 10 25 40 55 70 85 
15 13 11 9 7

l1 = [] # 先定义一个空列表
for i in range(20):
    if i % 2 == 1:
        l1.append(i)    # 奇数添加到列表中
print(l1)

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

l1 = [i for i in range(20) if i%2==1]
print(l1)

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

g1 = (i for i in range(20) if i%2==1)
print(g1)
print(next(g1))  # 使用next()函数获取生成器的第一个值
print(next(g1))  # 使用next()函数获取生成器的下一个值
print(list(g1))  # 将生成器转换为列表，可以生成过的值都已经被删除了
print(list(g1))  # 上面的行为获取了生成器中所有的剩余值，因此生成器已经空了

<generator object <genexpr> at 0x000002C60E4D7440>
1
3
[5, 7, 9, 11, 13, 15, 17, 19]
[]

for i in range(100, 1000):
    num_str = str(i)
    d1, d2, d3 = int(num_str[0]), int(num_str[1]), int(num_str[2])
    if d1**3 + d2**3 + d3**3 == i:
        print(f"最小的水仙花数是：{i}")
        break

最小的水仙花数是：153

for i in range(100, 1000):
    num_str = str(i)
    d1, d2, d3 = int(num_str[0]), int(num_str[1]), int(num_str[2])
    if d1**3 + d2**3 + d3**3 != i:      # 判断不是水仙花数，就跳出本次循环，不打印
        continue
    print(i)    # 是水仙花数就打印

153
370
371
407

def func():
    print("这是一个函数")

print(type(func))
print(func)
func()

<class 'function'>
<function func at 0x00000215C7187F60>
这是一个函数

def add(a, b):
    return a + b

print(add(2, 3))
print(add('Hello ', 'World'))

5
Hello World
<function add at 0x00000215C7186340>

def func1():        
    pass    # 表示一个空的代码段

print(func1())

None

def add(a, b):
    return a + b

print(add(2, 3))


def subtract(a, b=1):
    return a - b

print(subtract(5))


def multiply(a, b):
    return a * b

print(multiply(b=4, a=5))


def summation(*args):       # 接收任意数量的位置参数一般习惯用args这个名字，当然其他名字也可以
    result = 0
    for i in args:
        result += i
    return result

print(summation(1, 2, 3, 4, 5))


def product(**kwargs):     # 接收任意数量的关键字参数一般习惯用kwargs这个名字，当然其他名字也可以
    result = 1
    for i in kwargs.values():
        result *= i
    return result

print(product(a=2, b=3, c=4, d=5))


def all_kinds_of_args(a, b=1, *args, **kwargs):
    print(a, b, args, kwargs)

all_kinds_of_args(1, 2, 3, 4, 5, x=6, y=7)  # args打印出来是一个元组，kwargs打印出来是一个字典

5
4
20
15
120
1 2 (3, 4, 5) {'x': 6, 'y': 7}

def func1(l = []):
    l.append(1)
    return l

print(func1())
print(func1())
print(func1())

[1]
[1, 1]
[1, 1, 1]

def func1(l = []):
    l = []
    l.append(1)
    return l

print(func1())
print(func1())
print(func1())

[1]
[1]
[1]

def func1(a, b, c):
    return a, b, c

print(func1(1, 2, 3))   # 返回多个值，则会用一个元组包裹起来

(1, 2, 3)

l1 = [1, 2, 3, 4, 5]
print(list(filter(lambda x: x % 2 == 0, l1)))

# lambda x: x % 2 == 0 等价于下面这个函数
def is_even(x):
    return x % 2 == 0

print(list(filter(is_even, l1)))

[2, 4]
[2, 4]

# 引入模块中指定的东西
from math import sin, cos, pi
print(sin(pi/6), cos(pi/6))

# 引入模块中所有的东西
from math import *
print(exp(1), log(10), sqrt(2))

# 引入模块中所有的东西，调用时必须使用指定模块名
import random
print(random.randint(1, 10))

# 导入模块时，可以给模块指定别名
import random as rd
print(rd.randrange(1, 10))

0.49999999999999994 0.8660254037844387
2.718281828459045 2.302585092994046 1.4142135623730951
4
2

f = open("test.txt", "w")
f.write("Hello World!")
f.close()

f = open("test.txt", "r")
print(f.read())
f.close()

Hello World!

with open('test.txt', 'w') as f:
    f.write('Hello, world!')
    
with open('test.txt', 'r') as f:
    print(f.read())

import pandas as pd

df = pd.read_excel('data.xlsx')

print(df)

# 将整个DataFrame转换为一个字典，列名为键，数据列为值
df_dict = df.to_dict()
print(df_dict)

# 将每一行转换为一个字典，列名为键，行数据为值
df_dict = df.to_dict('records')
print(df_dict)

# 将列转换为字典，列名为键，单个值为值
df_dict = df.to_dict('list')
print(df_dict)

   姓名            学号       班级    绩点  名次
0  张三  202500998877  自动化25.1  99.7   3
1  李四  202500996655  自动化25.2  99.8   2
{'姓名': {0: '张三', 1: '李四'}, '学号': {0: 202500998877, 1: 202500996655}, '班级': {0: '自动化25.1', 1: '自动化25.2'}, '绩点': {0: 99.7, 1: 99.8}, '名次': {0: 3, 1: 2}}
[{'姓名': '张三', '学号': 202500998877, '班级': '自动化25.1', '绩点': 99.7, '名次': 3}, {'姓名': '李四', '学号': 202500996655, '班级': '自动化25.2', '绩点': 99.8, '名次': 2}]
{'姓名': ['张三', '李四'], '学号': [202500998877, 202500996655], '班级': ['自动化25.1', '自动化25.2'], '绩点': [99.7, 99.8], '名次': [3, 2]}

	Jupyter源文件(.ipynb)	Python文件(.py)
文件格式	JSON	纯文本
交互式环境	支持交互式编程和数据可视化	不支持
可读性	易于理解和阅读	需要更多的代码注释
可拓展性	支持将多个代码块组织在一个文件中	通常一个文件包含一个独立的功能或任务
代码执行	可逐个执行代码块	顺序执行整个文件中的所有代码
可分享性	可以分享包含代码、图像和文本的完整笔记本	通常需要将代码和相关文档一起分享
代码重用	可以轻松复制和粘贴代码块	更适合编写可重用的函数、类和模块

模式	描述
r	读取模式，文件必须存在，否则报错
w	写入模式，文件不存在则创建，存在则覆盖
a	追加模式，文件不存在则创建，存在则在末尾追加
r+	读写模式，文件必须存在，否则报错
w+	读写模式，文件不存在则创建，存在则覆盖
a+	读写模式，文件不存在则创建，存在则在末尾追加
b	二进制模式，用于读写二进制文件

Python基础知识¶

1 Python概述¶

2 Python开发推荐IDE¶

3 Python文件和Jupyter源文件¶

4 Markdown文件¶

5 最基础的 Python 程序¶

6 变量与数据类型¶

6.1 变量（一）¶

6.2 数字类型¶

6.2.1 整数（int）¶

6.2.2 浮点数（float）¶

6.2.3 复数（complex）¶

6.3 布尔类型（bool）¶

6.4 字符串类型（str）¶

6.5 列表类型（list）¶

6.6 元组类型（tuple）¶

6.7 集合类型（set）¶

6.8 字典类型（dict）¶

6.9 空类型（None）¶

6.10 其他一些类型¶

6.11 数据类型之间的相互转换¶

6.12 变量（二）¶

7 运算符¶

8 控制结构¶

8.1 顺序结构¶

8.2 选择结构（条件判断）¶

8.3 循环结构¶

9 函数¶

10 模块和包¶

11 虚拟环境¶

11.1 虚拟环境的特点¶

11.2 虚拟环境的创建¶

11.2.1 通过Python标准库venv来创建¶

12 文件操作¶