Two-

python基础02

条件控制

1. python条件语句是通过一条或多条语句的执行结果（Ture或者False）来执行的代码块
2. python中用elif代替了else if，所以if语句的关键字为：if-elif-else。

• 注意
• 每个条件后面都要用冒号：，表示接下来是满足条件后要执行的语句块
• 使用缩进来划分语句块，相同缩进数的语句在一期组成一个语句块
• 在python中没有switch-case语句

#if-else语句
age = int(input("请输入年龄:"))
if age >= 7:
    print("可以上小学")
else:
    print("年龄未满足要求，不可以上小学")
---------------------------------------------------
请输入年龄:8
可以上小学
---------------------------------------------------
请输入年龄:3
年龄未满足要求，不可以上小学

#if-elif语句
holiday_name = input("请输入节日：")
if holiday_name == "儿童节":
    print("是小孩子的节日！")
elif holiday_name == "端午节":
    print("今天要吃粽子！！")
elif holiday_name == "情人节":
    print("今天要买一束花送给她！")
else :
    print("今天是努力的一天！")

#if嵌套语句
list1 = [1,3,5,9,"apple","bee"]
a = input("请输入")
if a in list1:
    if a == "apple":
        print("Ture")
    else:
        print(False)
else:
    print("请重新尝试")
---------------------------------------------------
请输入apple
Ture

三元运算（三目运算）

三元运算符是对简单的条件语句的简写

• 写法：max = a if a>b else b

#三元运算符
a = int(input("输入a:"))
b = int(input("输入b:"))
print("a大于b") if a>b else print("b大于a") if a<b else print("a等于b")
---------------------------------------------------
输入a:3
输入b:3
a等于b

循环语句

python中的循环语句有for和while

1. 在python中没用do….while循环
2. 可以通过设置条件表达式永远不为false来实现无限循环

while循环

while循环使用else语句：如果while后面的体哦阿健语句为false时，泽执行else的句块

#一般形式
while 判断条件(condition):
      执行语句(statements)....

#while循环语句
count = 0
while count < 5:
    print(count,"小于5")
    count = count + 1
else :
    print(count,"大于等于5")
---------------------------------------------------
0 小于5
1 小于52 小于5
3 小于5
4 小于5
5 大于等于5

for循环

for循环可以遍历任何可迭代对象

• 字符串/列表/元组/字典/集合/generator(生成器)/iterator(迭代器)都是可迭代的
• 可用for去访问上述中内的每一个元素
• break语句用于跳出当前循环体

#本金10000元存入银行，年利率是千分之三，每过1年，将本金和利息相加作为新的本金。计算5年后，获得的本金是多少？
benjin = 10000
nianlilv = 0.0003

for i in range(1,6):
    new = (benjin*nianlilv+benjin)
    benjin = new
print("五年后获得的本金为：",benjin)
----------------------------------------------------
五年后获得的本金为： 10015.009002700404

遍历技巧

在字典遍历中，关键字和对应的值可以使用items()方法同时解读出来：items()方法以列表返回试图对象，是一个可便利的key/value对

#items()方法字典遍历
knights = {"gallahad":"the pure","robin":"the brave"}
for k,v in knights.items():
    print(k,v)
---------------------------------------------------
gallahad the pure
robin the brave

在序列遍历中，索引位置和对应值可以使用enumerate()函数同时得到：enumerate()函数用于可便利的数据对象（如列表、元组、字符串）组合为一个索引序列，同时列出数据和数据下标，一般用于for循环当中

#enumerate()函数进行序列遍历
for i,v in enumerate(["tic","tac","toe"]):
    print(i,v)
---------------------------------------------------
0 tic
1 tac
2 toe

同时遍历两个或多个序列时，可以使用zip()组合。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 ***** 号操作符，可以将元组解压为列表。

#zip()函数将对象元素打包
a = [1,2,3]
b = {"ada","dasd","ads","aaaa"}
for x,y in zip(a,b):
    print(x,y)
---------------------------------------------------
1 dasd
2 aaaa
3 ads

#zip()函数依次取出二位列表的每列函数
list1 = [[1, 2, 3, 4, 5, 6], 
         [1, 3, 5, 7, 9, 11], 
         [3, 4, 5, 6, 8, 9],
         [2, 4, 6, 8, 10, 12],
         [0, 3, 5, 7, 9, 0], 
         [5, 6, 8, 2, 3 ,4]]
for i in zip(*list1):
    print(i)

reversed()函数返回一个反转的迭代器，因此要反转一个序列，首先指定这个序列然后调用reversed()函数

#reversed()函数反转迭代器
star = "qwert"
print(list(reversed(star)))
-----------------------------------------------------
["t", "r", "e", "w", "q"]

要按顺序遍历一个序列，可以使用sorted()函数返回一个已经排序的序列，并不修改原值。

• sorted()函数可以对所有可迭代对象进行排序操作
• list.sort()方法改变的为原始的list，返回值为None，而sorted()返回的是一个新的list，不会在原来的list基础上进行改变
• list.sort()方法只为list定义，而sorted()函数可以接受任何的iterable（迭代对象）

#sorted()函数遍历排序
a = sorted([5,6,2,4,3,9,8]) #默认升序
print(a) 
b = a.sort() #list.sort方法返回的是原始的列表，值为None
print(b)
-----------------------------------------------------
[2, 3, 4, 5, 6, 8, 9]
None

Pass语句

在python中pass是空语句，是为了保持程序结构的完整性，pass不做任何事情，一般用做占位语句

#pass语句占位
while True:
    pass
-----------------------------------------------------
#返回为空

迭代器与生成器

1. 迭代器是python最强大的功能之一，是访问集合元素的一种方式
2. 迭代器是一个可以记住遍历的位置的对象
3. 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问结束；迭代器只能前进不能后退
4. 迭代器有两个基本的方法：iter()和next()
5. 字符串，列表或元组对象都可用于创建迭代器

#简单的迭代器
list1 = [1,2,4,5,6]
a = iter(list1) #创建迭代器对象
print(next(a)) #输出迭代器的下一元素
print(next(a))
print(next(a))
-----------------------------------------------------
1
2
4

迭代器对象可以使用常规for语句进行遍历

#使用for语句进行迭代器遍历
list1 = [1,2,4,5,6]
a = iter(list1)
for x in a:
    print(x,end="") #end传递空字符串，意为末尾不换行加空格
-----------------------------------------------------
12456

生成器/yield与return区别

什么是生成器？可以通俗的认为，在一个函数中，使用yield来代替return的位置的函数就是生成器

yield

1. 在python中，使用了yield的函数被称为生成器（generator）
2. 跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器
3. 在调用生成器运行的过程中，每次遇到yield时函数会暂停并保存当前所有的运行信息，返回yield的值，并在下一次执行next()方法时从当前位置继续运行
4. 调用一个生成器函数，返回的是一个迭代器对象

return

1. ruturn每次返回的是一个list列表，空间占用较大
2. return只会返回一个值，且return后面的代码不会执行

不同之处

1. yield在调用生成器的时候，会将数据生成为object，每次需要调用next()函数进行下一步的执行，同时不可逆
2. yield输出的是一个对象，相当于容器，想要什么数据就取出什么数据，而return只会返回一个值，且后面代码不会执行
3. 参考一个很好的例子：水车，先yield来装入数据、产出generator object、使用next()来释放；好比水车转动后，车轮上的水槽装入水，随着轮子转动，被转到下面的水槽就能将水送入水道中流入田里。

yield相较于return的优点

• 反应更迅速
• 更节省空间
• 使用更加灵活

参考

• (77条消息) python中的yield和return的区别_AcceptedLin的博客-CSDN博客_python yield和return的区别

函数

1. 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段
2. 函数能提高应用的模块性，和代码的重复利用率

自定义函数

自定义函数规则

1. 自定义函数代码块以def关键词开头，后接函数标识符名称和圆括号()
2. 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数
3. 函数的第一行语句可以选择性的使用文档字符串——用于存放函数说明（即注释，可以使用 .doc 进行调用文档字符串属性）
4. 函数内容以冒号：起始，并且缩进
5. return【表达式】结束函数，选择性的返回一个值给调用方，不带表达式的return相当于返回None

#自定义函数求圆的面积
import math
pi=math.pi #引用Π值

def yuan(r):
    s = pi*r*r
    return s
r = float(input("请输入半径："))
s = print(yuan(r))
---------------------------------------------------
请输入半径：5
78.53981633974483

参数传递

参数传递分为传不可变对象以及传可变对象

• ps：见One可变数据与不可变数据类型

参数

以下是调用函数时可使用的正式参数类型：

必须参数/关键字参数/默认参数/不定长参数

必须参数

• 必须参数需要以正确的顺序传入函数。因此也叫位置参数，调用时的数量必须和声明时的一样，且位置参数必须放置在关键词参数之前

#调用printme()函数
def printme(str): 
    print(str) #打印任何传入的字符串
    return
printme() #未传参报错
---------------------------------------------------
TypeError: printme() missing 1 required positional argument: "str"

关键字参数

• 关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值
• 使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为python解释器能够用参数名匹配参数值

#调用printinfo()函数
def printinfo(name,age):
    print("姓名：",name)
    print("年龄：",age)
    return
printinfo(age=19,name="runoob")
---------------------------------------------------
姓名： runoob
年龄： 19

默认参数

• 调用函数时，如果没用传递参数，则会使用默认参数
• 如下如果没用传入age参数，则使用默认值

#默认参数
def printinfo(name,age = 35):
    print("姓名：",name)
    print("年龄：",age)
    return
printinfo(age=19,name="runoob")
print("------------------------------")
printinfo(name="runoob")
---------------------------------------------------
姓名： runoob
年龄： 19
------------------------------
姓名： runoob
年龄： 35

不定长参数

• 如果在函数调用时没用指定参数，它就是一个空元组，我们也可以不向函数传递未命名的变量
• 不定长参数类型有两种：1.*+参数名 2.**+参数名

*+参数名

• 这种情况下在调用时会自动组装成一个元组
• 允许传入0个或任意多个参数

#不定长参数第一种
def sum(*crad):
    sum = 0
    for weight in crad:
        sum += weight
        if sum > 500:
            print("超重了！再不下，就给你一个大笔兜")
    return sum
sum_s = sum(50,80,200,200) #自动组成一个元组传入形参
----------------------------------------------------
超重了！再不下，就给你一个大笔兜

**+参数名

• 允许传入0个或任意多个参数
• 这些参数会被自动组装成一个字典，而不是元组
• 实参必须包含参数名，参数名作为字典的键，参数值作为字典的值

#不定长参数第二种
def student_n(**info):
    print(info)
    dict = info
    return dict
dict = student_n(name="小王",id="001",score="82")
----------------------------------------------------
{"name": "小王", "id": "001", "score": "82"}

单独出现*的参数

声明函数时，参数中星号*可以单独出现，如果单独出现星号后的参数必须用关键字传入

#*关键字传参
def f(a,b,*,c):
    return a+b+c
f(1,2,3) #星号后未用关键字传参导致报错
----------------------------------------------------
Traceback (most recent call last):
  File "f:/python_prictace/02-python.py", line 187, in <module>
    f(1,2,3)
TypeError: f() takes 2 positional arguments but 3 were given

#*关键字传参
def f(a,b,*,c):
    return a+b+c
print(f(1,2,c=3))
----------------------------------------------------
6

混合使用

#混合使用
def foo(*args,**kargs):
    print(args)
    print(kargs)
foo(a=2,1,2,3) 
#当同时使用*和**时，必须将*的参数列在**的前面，否则会报错
----------------------------------------------------
File "f:/python_prictace/02-python.py", line 196
    foo(a=2,1,2,3)
            ^
SyntaxError: positional argument follows keyword argument

#混合使用
def foo(*args,**kargs):
    print(args)
    print(kargs)
foo(1,2,3,a=2) 
----------------------------------------------------
(1, 2, 3)
{"a": 2}

匿名函数

1. python使用lambda来创建匿名哈桉树
2. 所谓匿名函数，意为不再使用def语句标准的形式定义一个函数
3. lambda只是一个表达式，函数体比def简单的多
4. lambda的主体时一个表达式，而不是一个代码块；仅仅能在lambda表达式中封装有限的逻辑进去
5. lambda函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数
6. 虽然lambda函数看起来只能写一行，却不同于c或c++的内联函数，后者的目的是调用小函数时不占用栈内存，从而增加运行效率

#lambda表达式创建一元二次方程
def fx(a,b,c):
    return lambda x : a*x*x + b*x + c
f = fx(1,2,3)
print(f(3))
----------------------------------------------------
18