1，流程控制
1.1，顺序结构
1.1.1，if分支结构
if分支使用布尔表达式或布尔值作为分支条件来进行分支控制。
#第一种形式
if expression:
statement...
#第二种形式
if expression:
statement...
else:
statement...
#第三种形式
if expression:
statement...
elif expression:
statement...
elif expression:
statement...
注意：Python是一门很独特的语言，它的代码是通过缩进来标记的，具有相同缩进的多行代码属于同一个代码块。如果代码莫名其妙地乱缩进，Python解释器会报错。
如果忘记缩进，就不是代码块：
age = 22
if age >20:
print(age)
print("你已经是叔叔了")
如果随意缩进，将会报错：
age = 22
if age >20:
print(age)
print("你已经是叔叔了")
1.1.2，if条件的类型
Python执行if语句时，会判断if条件是True还是False。但实际上，if条件可以是任意类型，当下面的值作为bool表达式、空字典等都会被当作False处理。
False、None、0、""、()、[]、{}
除了False本身，各种代表“空”的None、空字符串、空元祖、空列表、空字典都会被当成False处理。
s = ""
if s:
print("s不为空")
else:
print("s不能为空")
1.1.3，pass语句
Python的pass语句就是空语句，有时候程序需要占一位、放一条语句，但又不希望这条语句做任何事情，此时就可通过pass语句来实现。通过使用pass语句，可以让程序更完整。
s = "1"
if s:
pass
else:
print("s不能为空")
1.2，断言
断言语句和if分治有点类似，它用于对一个bool表达式进行断言，如果该bool表达式为True，该程序可以继续向下执行；否则程序会引发AssertionError错误。
a = input("年龄：")
a = int(a)
assert 20 < a < 80
print("年龄正常")
==================
年龄：1
Traceback (most recent call last):
File "E:/Pycharm/WorkSpace/Study/main.py", line 3, in <module>
assert 20 < a < 80
AssertionError
1.3，循环结构
1.3.1，while循环
while循环的语法格式如下：
[init_statements]
while test_expression:
body_statements
[iteration_statements]
如果循环条件为True，会导致这个循环永远无法结束。?
i = 0
while i < 10:
print(i)
i += 1
print("结束循环")
1.3.2，使用while循环遍历列表和元组
由于列表和元组都是有索引的，因此程序可通过while循环、列表或元组的索引来比那里列表和元素中的所有元素。
a = ("燕双嘤", "杜马", "陈恭鹏")
i = 0
while i < len(a):
print(a[i])
i += 1
1.3.3，循环使用else
Python的循环可以定义else代码块，当循环条件为False时，程序会执行else代码块。
i = 0
while i < 5:
print(i)
i += 1
else:
print("大于或等于5")
1.3.4，for-in循环
for-in循环专门用于遍历范围、列表、元素和字典等可迭代对象包含的元素。for-in循环的语法格式如下：
for 变量 in 字符串|范围|集合等:
statement
for-in循环中的变量的值受for-in循环控制，该变量将会在每次循环开始时自动被赋值，因此程序不应该在循环中对该变量赋值。
for-in循环可用于遍历任何可迭代的对象。所谓迭代对象，就是指该对象中包含一个_iter_方法，且该方法的返回值对象具有next()方法。
for i in range(1,10,1):
print(i)
PS：for-in循环的循环计数器赋值在语法上是允许的，但是没有什么意义。?
1.3.5，使用for-in循环遍历列表和元组
在使用for-in循环遍历列表和元组时，列表或元组有几个元素，for-in循环的循环体就执行几次，针对每个元素执行一次，循环计数器会一次被赋值为元素的值。
a = ("燕双嘤","杜马","步鹰")
for i in a:
print(i)
for i in range(0,len(a)):
print(a[i])
1.3.6，使用for-in循环遍历字典
使用for-in循环遍历字典其实也是通过遍历普通列表来实现的。通过以下方法：
- items()：返回字典中所有key-value的列表。
- keys()：返回字典中所有key的列表。
- values()：返回字典中所有value的列表。
a = {"name": "燕双嘤", "sex": "男", "age": 22}
for key,value in a.items():
print(key,value)
print(key,a[key])
1.4，控制循环结构
1.4.1，使用break结束循环
某些时候，需要在某种添加出现时强制中止循环，而不是等到循环条件为False时才退出循环。此时可以使用break来完成这个功能。break用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到break，系统就将完全结束该循环，开始执行循环之后的代码。双层循环之跳出内层循环体。
for i in range(0,100):
print(i)
if i == 10:
break
1.4.2，使用continue忽略本次循环的剩下语句
continue的功能和break有点类似，区别是continue知识忽略当次循环的剩下语句，接着下一次循环，并不会中止循环；而break则是完全中止循环本身。
for i in range(0,100):
print(i)
if i == 10:
continue
print(123)
1.4.3，使用return结束方法
return用于从包围它的最直接方法、函数或匿名函数返回。当函数或方法执行到一条return语句时，这个函数或方法将被结束。Python程序中大部分循环都被放在函数或方法中执行，一旦在循环体内执行到一条return语句时，retrun语句就会结束该函数或方法，循环自然也随之结束。
def test():
for i in range(0, 100):
print(i)
if i == 10:
return
print(123)
if __name__ == '__main__':
test()
2，函数
2.1，函数的定义和调用
2.1.1，定义函数
定义函数的语法格式如下：
def 函数名(形参列表):
//由零条到多条可执行语句组成的函数
[return [返回值]]
Python声明函数必须使用def关键字，对函数语法格式的详细说明：
- 函数名：从语法角度来看，函数名只要是一个合法的标识即可；从程序的可读性角度来看，函数名应该由一个或多个有意义的单词组成，每个单词的字母全部小写，单词与单词之间使用下划线分隔。
- 形参列表：用于定义该函数可以接收的参数。形参列表由多个形参名组成，多个形参名之间以英文逗号（,）隔开。
def demo(x):
print("燕双嘤"+str(x))
return "哈哈哈"
print(demo("NB"))
2.1.2，多个返回值
如果程序需要有多个返回值，则既可将多个值包装成列表之后返回，也可直接返回多个值。如果Python函数值直接返回了多个值，Python会自动将多个返回值封装成元组。
def demo():
print("燕双嘤")
return "哈哈哈","嘤嘤嘤"
print(demo())
==========================
燕双嘤
('哈哈哈', '嘤嘤嘤')
2.2，函数的参数
2.2.1，关键字参数
按照形参位置传入参数被称为位置参数。如果使用位置参数的方式传入参数值，则必须严格按照定义函数时指定的顺序来传入参数值；如果根据参数名来传入参数值，则无须遵守定义形参的顺序，这种方式被称为关键字参数。
def demo(str1, str2):
print(str1, str2)
return "哈哈哈"
print(demo("燕双嘤", "NB"))
print(demo(str2="燕双嘤", str1="NB"))
==========================
燕双嘤 NB
哈哈哈
NB 燕双嘤
哈哈哈
2.2.2，参数默认值
在某些情况下，程序需要在定义函数时为一个或多个形参指定默认值——这样在调用函数式就可以省略为该形参传入参数值，而是直接使用该形参的默认值。
def demo(str,sex="男"):
return "姓名："+str+",性别："+sex
print(demo("燕双嘤"))
PS：多个参数时，有默认值的参数必须放在无默认值参数的后面。上面的str和sex就无法互换。
2.2.3，可变参数
Python允许在形参前面添加一个星号（*），这样就意味着该参数可接收多个参数值，多个参数值被当成元组传入。
def demo(a,*b):
print(a)
for i in b:
print(i)
demo("燕双嘤",1,2,3,4,5)
=======================
燕双嘤
1
2
3
4
5
PS：Python允许可变参数出现在列表的任何位置，但Python要求函数最多只能带一个支持“普通”参数收集的形参。
def demo(*b,a):
print(a)
for i in b:
print(i)
demo("燕双嘤",1,2,3,4,a=5)
demo()函数的第一个参数就是个数可变的形参，由于该参数可接收个数不等的参数值，因此如果需要给后面的参数传入参数值，则必须使用关键字参数；否则，程序会把所传入的多个值都当成是传给b参数的。
Python还可以收集关键字参数，此时Python会将这种关键字参数收集字典。为了让Python能收集关键字参数，需要在参数前面添加两个星号。在这种情况下，一个函数可同时包含一个支持“普通”参数收集的参数和一个支持关键字参数收集的参数。
def test(x, y, z=3, *names, **party):
print(x, y, z)
print(names)
print(party)
test(1, 2, 3, "燕双嘤", "杜马", 党派1="共产党", 党派2="国民党")
==================================================
1 2 3
('燕双嘤', '杜马')
{'党派1': '共产党', '党派2': '国民党'}
如果想让z参数的默认值发挥作用，则需要只传入两个位置参数。
test(1, 2, 3, 党派1="共产党", 党派2="国民党")
==============================
1 2 3
()
{'党派1': '共产党', '党派2': '国民党'}
2.2.4，逆向参数收集
所谓逆向参数收集，指的是在程序已有列表、元组、字典等对象的前提下，把它们的元素“拆开”后传给函数的参数。
def test(num1,num2, *nums):
print(num1)
print(num2)
print(nums)
list = [1, 2, 3]
test(*list)
======================
1
2
(3,)
2.2.5，函数传参机制（类似Java）
Python中函数的参数传递机制都是“值传递”，就是将实际参数值的副本传入函数，而参数本身不会受到任何影响。
def swap(a, b):
a, b = b, a
print("在swap函数里：", a, b)
a = 6
b = 9
swap(a, b)
print("交换结束后：", a, b)
==========================
在swap函数里： 9 6
交换结束后： 6 9
根据Python的参数传递机制，传入函数的只是参数的副本，因此程序在函数中对参数赋值并不会影响参数本身。如果参数本身是一个可变对象（列表、字典），此时虽然Python采用的也是值传递方式，但是会修改可变对象。
def swap(ab):
ab['a'], ab['b'] = ab['b'], ab['a']
print(ab["a"], ab["b"])
ab = {"a":6,"b":9}
swap(ab)
print(ab["a"], ab["b"])
==============================
9 6
9 6
2.2.6，变量作用域
在程序定义一个变量时，这个变量是有作用范围的，变量的作用范围被称为它的作用域。根据定义变量的位置，变量分为两种：
- 局部变量：在函数中定义的变量，包括参数，都被称为局部变量。每个函数在执行时，系统都会为该函数分配一块“临时内存空间”，所有的局部变量都被保存在这块临时内存空间内。当函数执行完成后，这块内存空间就被释放了，这些局部变量也就失效了，因此离开函数之后就不能再访问局部变量了。
- 全局变量：在函数外面、全局范围内定义的变量，都被称为全局变量。全局变量意味着它们可以在所有函数内被访问。
此外，Python提供了如下三个工具函数来获取指定范围内的“变量字典”：
- globals()：该函数返回全局范围内所有变量组成的“变量字典”。
- locals()：该函数返回当前局部返回内所有变量组成的“变量字典”。
- vars(object)：获取在指定对象范围内所有变量组成的“变量字典”。如果不传入object参数，vars()和locals()的作用完全相同。
globals()和locals()看似完全不同，但它们实际上也是有联系的，关于这两个函数的区别如下：
- locals()总是获取当前局部范围内所有变量组成的“变量字典”，因此，如果在全局范围内调用locals()函数，同样会获取全局范围内所有变量组成的“变量字典”；而globals()无论在哪里执行，总是获取全局范围内所有变量组成的“变量字典”。
- 一般来说，使用locals()和globals()获取的“变量字典”只应该被访问，不应该被修改。但实际上，不管是使用globals()还是使用locals()获取的全局范围内的“变量字典”，都可以被修改，而这种修改回真正改变全局变量本身；但通过locals()获取的局部范围内的“变量字典”，即使对它修改也不会影响局部变量。
def test():
age = 20
print(age)
print(locals())
locals()['age'] = 12
print(age)
globals()['x'] = 19
test()
x = 5
y = 20
print(globals())
print(locals())
print(x)
print(globals()['x'])
globals()['x'] = 39
print(x)
locals()['x'] = 99
print(x)
======================
20
{'age': 20}
20
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000017A902DC1D0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/Pycharm/WorkSpace/Study/main.py', '__cached__': None, 'test': <function test at 0x0000017A901D1EA0>, 'x': 5, 'y': 20}
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000017A902DC1D0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/Pycharm/WorkSpace/Study/main.py', '__cached__': None, 'test': <function test at 0x0000017A901D1EA0>, 'x': 5, 'y': 20}
5
5
39
99
在函数中声明全局变量
name = "燕双嘤"
def test():
global name
print(name)
name = "杜马"
test()
print(name)
=================
燕双嘤
杜马
|