置顶 |

Python基础

python基础2

一.流程控制语句

重点说明这节课的重要性，分水岭，进阶到逻辑性的东西

上节回顾

  • set集合 用{} 包裹的数据（字符串，数字，元组）就是集合，特点 ，去重，无序的，
    • {“韦小宝”, 12, (123,999)}
  • dict字典 用{} 包裹的 数据 （键值对 ）就是 字典， 特点 数据是以键值对类型的， 什么数据都可以放，
    • {“name”:”阿飞”, “age”: 18}

程序三大流程控制

流程控制即控制流程，具体指控制程序的执行流程，而程序的执行流程分为三种结构：顺序结构、选择结构、循环结构

  • 顺序结构就是让程序按照从头到尾的顺序依次执行每一条 Python 代码，之前我们写的代码都是顺序结构
  • 选择结构也称分支结构，就是让程序“拐弯”，有选择性的执行代码
  • 循环结构就是让程序“重新做一遍”，不断地重复执行同一段代码。

分支结构(判断语句)

大家想一想

生活中有哪些判断场景

  • 火车站安检

    image.png

  • 上网吧

    image.png

  • 密码判断

    image.png

小结：

  • 如果某些条件满足，才能做某件事情；条件不满足时，则不能做，这就是所谓的判断。
  • 不仅生活中有，在软件开发中”判断”功能也经常会用到

单分支(if)

1
2
3
如果 
if 要判断的条件:  # True 、False 
    条件成立时，要做的事情

demo1:

1
2
3
4
5
6
7
age = 30

print("if 判断开始")
if age >= 18:
    print("已成年了，可以上网了")

print("if 判断结束")

demo2:

1
2
3
4
5
6
7
age = 17

print("if 判断开始")
if age >= 18:
	print("已成年了，可以上网了")

print("if 判断结束")

小总结：

  • 以上2个demo仅仅是age变量的值不一样，导致结果却不同；能够看得出if判断语句的作用：就是当满足一定条件时才会执行代码块(也就是条件判断)(语句，否则就不执行代码块语句。
  • 注意：代码的缩进为一个tab键，或者4个空格

想一想

判断age大于或者等于18岁使用的是 >=，如果是其他判断，还有哪些呢？

比较运算符和 逻辑运算符

比较运算符

python中的比较运算符如下表

运算符 描述 示例
== 检查两个操作数的值是否相等，如果是则条件变为真。 如a=3,b=3，则（a == b) 为 True
!= 检查两个操作数的值是否相等，如果值不相等，则条件变为真。 如a=1,b=3，则(a != b) 为 True
> 检查左操作数的值是否大于右操作数的值，如果是，则条件成立。 如a=7,b=3，则(a > b) 为 True
< 检查左操作数的值是否小于右操作数的值，如果是，则条件成立。 如a=7,b=3，则(a < b) 为 False
>= 检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。 如a=3,b=3，则(a >= b) 为 True
<= 检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。 如a=3,b=3，则(a <= b) 为 True

逻辑运算符

运算符 逻辑表达式 描述 实例
and x and y 布尔”与”：如果 x 为 False，x and y 返回 False，否则它返回 y 的值。 True and False， 返回 False。
or x or y 布尔”或”：如果 x 是 True，它返回 True，否则它返回 y 的值。 False or True， 返回 True。
not not x 布尔”非”：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not True 返回 False, not False 返回 True 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
>>> ## 逻辑运算符
...
>>>
>>> # and 左右表达式都为True，则结果为True
...
...
>>> if (1 == 1) and (10 > 3):
...     print("条件成立")
...
条件成立


>>> # or 左右两边表达式有一个为True，则结果为True
...
>>> if (100 == 100) or (10 < 3):
...     print("条件成立")
...
条件成立

>>> # not  将右边表达式的逻辑结果取反，True变为False， False 变为True
>>> if not (1==2):
...     print("条件成立")
...
条件成立

双分支(if-else)

满足条件时做什么，那不满足时做什么呢？
答 ：if-else

1
2
3
4
5
6
7
8
9
10
if 条件:
	满足条件时要做的事情1
	满足条件时要做的事情2
	满足条件时要做的事情3
	...(省略)...
else:
	不满足条件时要做的事情1
	不满足条件时要做的事情2
	不满足条件时要做的事情3
	...(省略)...

demo:

1
2
3
4
5
6
7
8
9
10
age = 17

print("if 判断开始")
if age >= 18:
    print("已成年了，可以上网了")
else:
    print("未成年，禁止上网")
print("if 判断结束")


多分支（if-elif-elif…）（if-elif-elif-…-else）

if 能完成当xxx时做什么事情1，

if-else能完成当xxx时做事情1，否则做事情2

如果有这样一种情况：当xxx1满足时，做事情1；当xxx1不满足时，xxx2满足时做事情2；当xxx2不满足时，xxx3 满足时做事情3 ，那怎么实现呢？

1
2
3
4
5
6
7
8
if xxx1:      健康码  绿码
	事情1           做核酸
elif xxx2:           黄码
	事情2    			叫我需要去另外一个地方做
elif xxx3: 			体温38度
	事情3     		 隔离
elif xxx4: 			体温38度
	事情4

demo:

1
2
3
4
5
6
7
8
9
10
11
12
13
pick_che = 0   # 1 表示买票了， 0 表示没有买票
weijin = 0     # 1 表示有违禁品， 0 表示没哟


if weijin:
    print("那不能进入车站")

elif pick_che:
    print('可以进入车站')

else:
    print("没有车票回去购买")

注意：

elif必须和if一起使用，否则出错

else 一般用在最后，即所有条件都不满足时使用

if 嵌套

通过学习已经知道了

  • 满足xxx时做事情a ，用 if
  • 满足xxx时做事情a，不满足时做事情b 用 if-else

想一想

坐火车或者地铁的实际情况是：先进行安检如果安检通过才会判断是否有车票，或者是先检查是否有车票之后才会进行安检，即实际的情况某个判断是再另外一个判断成立的基础上进行的，这样的情况该怎样解决呢？

1
2
3
4
5
6
7
if 条件1成立:
	做的事情1
	做的事情2.....

	if 条件2成立:
		做的事情1...
		做的事情2...
  • 说明 注意缩进
    • 外层的if判断，也可以是if-else
    • 内层的if判断，也可以是if-else
    • 根据实际开发的情况，进行选择

demo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
pick_che = 1 # 1 表示买票了， 0 表示没有买票
weijin = 0 # 1 表示有违禁品， 0 表示没哟


if not weijin:
    print("可以进入车站")

    if pick_che:
        print('可以去见女朋友了')
    else:
        print("请购票，先生")
else:
    print("携带违禁品，等待警察处理")


循环结构(循环语句)

《1》生活中的循环场景

操场

image.png

电风扇

cat.gif

《2》程序中的循环使用场景

跟女朋友承认错误，说一万遍“宝贝，我错了”

1
2
3
4
5
print("宝贝，我错了")
print("宝贝，我错了")
print("宝贝，我错了")
print("宝贝，我错了")
。。。。

使用循环语句一句话搞定

1
2
3
4
5
i = 0
while i< 10001:
    print("宝贝，我错了")
    i +=1

小总结

  • while和if的用法基本类似，区别在于：if 条件成立，则执行一次； while 条件成立，则重复执行，直到条件不成立为止。
  • 一般情况下，需要多次重复执行的代码，都可以用循环的方式来完成
  • 循环不是必须要使用的，但是为了提高代码的重复使用率，所以有经验的开发者都会采用循环

while语句

1
2
3
4
5
while 条件:
	条件满足时，做的事情1
	条件满足时，做的事情2
	条件满足时，做的事情3
	...(省略)...

demo:

1
2
3
4
5
6
i = 0
while i < 5:
    print("当前执行的次数，%d" %(i +1))
    print("i =%d" % i)
    i +=1

while嵌套

要求：打印如下的图形

1
2
3
4
5
*
* *
* * *
* * * *
* * * * *
1
2
3
4
5
6
7
8
9
i = 1
while i <=5: # 4 <= 5
    j = 1
    while j <=i:  # 3 <= 4:
        print("* ", end="") # 取消 换行  用ctrl键+点击鼠标  可以查看鼠标指定的位置代码的源码
        j +=1
    print("\n")
    i +=1

for 循环

在Python中for循环可以遍历任何序列的类型，如一个列表或字符串

1
2
for 临时变量 in 列表或者字符串等可迭代对象:  
    循环满足条件时执行的代码

demo:

1
2
3
for i in "hello world":
    print(i)

结果：

1
2
3
4
5
6
7
8
9
10
11
h
e
l
l
o
 
w
o
r
l
d

demo2:

1
2
3
4
5
6
7
8
9
10
11
for x in range(5):
    print(x)

'''
效果等同于 while 循环的：

i = 0
while i < 5:
    print(i)
    i += 1
'''

补充：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
range里面的值:
       1.默认从0开始
       2.终点值到它的前一位

   for i in range(数值):
       执行语句

   for i in range(50):
       print(i) # 输出0-49

   for i in range(50,101):
       print(i) # 自定义起点.输出50-100

   for i in range(50,101,2):
       print(i) # 这里的2为步长

break和continue

1.break

1
2
for x in range(5):
    print(x)

带有break的循环

1
2
3
4
for x in range(5):
    if x == 3:
        break  # 结束循环
    print(x)

continue

1
2
3
4
for x in range(5):
    if x == 3:
        continue  # 跳过循环
    print(x)

总结：

  • break的作用：立刻结束break所在的循环
  • continue的作用：用来结束本次循环，紧接着执行下一次的循环，相当于跳过了当前这次循环

注意点

  • break/ continue 只能用在循环中，除此以外不能单独使用
  • break/continue 在嵌套循环中，只对最近的一层循环起作用

作业

1.要求：从键盘输入身高，如果身高没有超过150cm，则进动物园不用买票，否则需要买票。

2.编写代码，1-7七个数字，分别代表周一到周日，如果输入的数字是6或7，输出“周末”，如果输入的数字是1-5,输 出“工作日”，如输入其他数字，输出“错误”。

3.情节描述：上公交车去公园，并且可以有座位坐下

要求：输入公交卡当前的余额，只要超过2元，就可以上公交车,否则走着去；如果车上有空座位，就可以坐下，否则就站着吧。

4.输出 1-100 内的所有奇数（for，while 都可以）

5.99乘法表

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
# 1.要求：从键盘输入身高，如果身高没有超过150cm，则进动物园不用买票，否则需要买票。
# a = int(input("请输入用户身高 cm"))
# if a > 150 :
#     print("请买票进入")
# else:print("请进入！")

# 2.编写代码，1-7七个数字，分别代表周一到周日，如果输入的数字是6或7，输出“周末”，如果输入的数字是1-5,输 出“工作日”，如输入其他数字，输出“错误”。
# i = int(input("请输入相应的值i："))
# if (i == 6) or (i == 7) :
#     print("周末")
# elif 1 <= i and i <= 5:   # 1 <= i <= 5
#     print("工作日")
# else:
#     print("错误！")
# 3.情节描述：上公交车去公园，并且可以有座位坐下
# 要求：输入公交卡当前的余额，只要超过2元，就可以上公交车,否则走着去；如果车上有空座位，就可以坐下，否则就站着吧。
# m = int(input("请输入公交卡当前的余额："))
# if (m > 2):
#     print("请上车")
#     n = int(input("1  有座位   0   无座位 请输入"))
#     if(n==1):
#         print("坐下")
#     else:print("站着")
# else:print("走着去")

# 4.输出 1-100 内的所有奇数（for，while 都可以）
for i in range(1,101,2):
    print(i)
print("=============")
for i in range(1,101):
    if i % 2 != 0 :
        print(i)

print("-------------------")
n = 0
while True: # 死循环
    if n == 100:
        break
    n += 1
    if n%2 != 0:
        print(n)

# 5.99乘法表
i = 1
while i <= 9: # 控制打印多少行
    j = 1
    while j <= i: # 控制打印多少行
        print(f"{i}*{j}={i*j}",end=' |')
        j += 1
    i += 1
    print()

print("===============")

for i in range(1,10):
    for j in range (1,i+1):
        if j <= i:
            print("{}*{}={}  ".format(i, j, i*j), end="")
            j += 1
    print("\n") # 多了个空格
    i += 1

课前预习

http://c.biancheng.net/python/function/ 函数

二.函数基础与函数参数

上节回顾

流程控制：

  • 顺序结构
  • 选择结构（if判断语句）
    • 单分支 if
    • 双分支 if -else
    • 多分支 if - elif - else
  • 循环结构
    • while
    • for
  • 解决循环
    • break （结束循环）
    • continue (跳出循环)
  • 逻辑运算符 and or not

初始函数

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
我现在想吃一个苹果。需要买一把水果刀，后面我需要做三杯鸡，需要买一把切肉刀，
有一天，我看到了瑞士军刀，它什么功能，都有了， 这样我就不需要买水果刀了，

瑞士军刀 >> 就是把一些功能结合到一起的函数


函数：
	通过的专门的代码，用来实现特定的功能

优点:
    1.独立性
    2.可以重复使用
    
    
定义一个函数  >> 封装一个功能
调用函数      >> 使用函数的功能


 # 如何定义一个函数  注意定义的函数名与规定的内置函数名一样会报错
    def 函数名():
        代码块
        
# 需要先定义，才能调用
	函数名()

# demo:
	def printInfo():
        
        print("-"*20)
        print("         人生苦短，我用Python           ")
        print("-"*20)

    printInfo()
    
    
# 定义一个空的函数
# pass 作为占位符
def fun1():
	pass


return 返回值(是个列表)

为什么要有返回值，或者，比如，这个函数完成 的是两个变量的相加，但是另一个函数的功能是需要这两个变量的和进行相加 这个时候就需要使用return把返回值返回出来，这样才能使用

例子：你计算的数据，要想给别人使用，怎么办，那你得拿出来，是吧，这里就是return 的作用，把数据return 出来，那么其他人就能使用了

1
2
3
4
5
6
7
8
9
10
11
12
13
# 定义有返回值的函数
# return / 返回值  / 结束函数
# 函数 默认返回值 None（空） 
def 函数名():
    代码块
    return 返回值 


# demo:
def fun1():
    rest = 100 +2
    return rest 
print(fun1())

小结：

return 返回值的类型，没有限制，不写返回值，默认返回None

return 可以返回多个值， 中间用，逗号隔开，得到的数据类型为元组

函数命名 与变量名规则一致

1
2
3
- 数字不能开头，首字母小写，其后的首字母大写（小驼峰）
- 见名知意
-

函数参数

  • 形参 >>> 函数定义时圆括号() 里的变量，对象， 定义时传入的
  • 实参 >>> 函数使用时圆括号（）里的传的数据 调用时传入的
  • 形参和实参的传入的名字尽量不要一样
1
2
3
4
5
6
7
8
9
10
11
12
# 定义带参数的函数------形参
def 函数名(形参1，形参2):
    代码块
	
# demo：
def fun2(money):
    print(f"今天收入{money}")
    
#调用时传入的为实参    
fun2(999)

## 形参与实参要一一对应

参数进阶

  • 默认参数 : 就是给参数一个默认值 必须在普通参数后面

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    定义时；
    	def 函数名(参1, 参2=123):
    调用:
        函数名(参1,)
        
    demo:
        def desc(name, age=18):
    		print(f"姓名{name}年龄{age}")
            
       desc("韦小宝")      # 姓名韦小宝年龄18
       desc("韦小宝", 2000)# 姓名韦小宝年龄2000

  • 可变参数： *args

    参数个数不定，但是接受后的数据为元组（）类型，

    • 参数名不固定 一般都是args 命名 前面 加个 *****
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    定义：
    	def 函数名(*可变参数):
            xxx
        def fun4(*args):

    调用：
    	函数名(参1，参2，参3，...):

     demo:
       def fun4(*args):
        #print(args)    #(123, 12.5, '123', [123, 'aa'], {'name': '言沫沫'})
        print(*args)  # 解包  123 12.5 123 [123, 'aa'] {'name': '言沫沫'}
        #print([*args])  #[123, 12.5, '123', [123, 'aa'], {'name': '言沫沫'}]
        #print({*args})  #unhashable type: 'list'
    fun4(123, 12.5, "123",[123,"aa"],{"name":"言沫沫"})

  • 关键字参数 （**kwargs）

    参数个数不定，但是接受后的数据为字典类型，

    • 参数名不固定， 一般都是 kwargs 前面 + **

      ​

    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
    定义：
    	def 函数名(**参数):
    	def fun4(**kwargs):
            
    调用：
    	函数名(**{字典})
        fun4(**{"时间":20,"地点": "Python课程"})
        
        
    demo:
    def fun4(**kwargs):

        print(kwargs) 
       
    # ** 只能对字典解包
    fun4(**{"时间":20,"地点": "Python课程"})  # 对字典 解包

    fun4(time=20, addr="python")

    demo:
    # # 定义一个函数。计算a，b 的和
    def mySum(a, b, name=123, *args, **kwargs):  # 形参 a，b
        print(a)              # 999
        print(b)              # 123
        print(args)           # (675, [123, 520], {'age': 2000})
        print(kwargs)         # {'name1': '韦小宝'}
        print(name,">>>>>>>>>>>")  # 34564 >>>>>>>>>>>
        # 解包
        print(name)                # 34564
        num1, num2, num3 = args
        print(num1, num2, num3)    # 675 [123, 520] {'age': 2000}
        return a + b  # return 返回值

    ####                        args   args       args         kwargs
      num = mySum(999,123,34564,675,[123,520],{"age":2000},**{"name1":"韦小宝"})
      print(num)    # 1122

    ​

    ​

    总结：

    参数的顺序一般为（从左到右）：普通参数 默认参数 可变参数（*args） 关键字参数（**kwargs）

    可变参数一般可以解包任何类型的数据 关键字参数只能解包字典类型的数据

    如果字典里解包后输出的键值名与前面的有重复 则会报错

    解包实质就是一种其他的解决方法

    ​

    ​

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20


    #解包demo

    tu1 = (123, 213)
    tu2 = (520, 1314)
    #元组解包
    tu3 = tu1 + tu2
    print(tu3 )         # (123, 213, 520, 1314)

    print((*tu1, *tu2))  # (123, 213, 520, 1314)


    reset1 = {"time": 120}
    reset2 = {"addr": "python课程"}

    reset1.update(reset2)
    #字典解包
    rest3 = {**reset1,**reset2}
    print(rest3)  # {'time': 120, 'addr': 'python课程'}

内置函数(基础篇)

python自带的一些功能函数,可以直接使用 这里列举

print() 输出语句
input() 输入语句
type() 获取数据类型
min() 获取最小值
max() 获取最大值
len() 获取数据长度(有几个数据)
sum() 获取数据的总值

文档字符串

针对函数的注释,看起来和注释一样,但是可以被用来调用输出,所以在写函数时更推荐用文档字符串

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
def 函数名():
    """ 文档字符串内容 """
        代码块

def fun():
    """
    这是一个测试函数
    我是一个文档字符串
    我可以被输出
    :return:
    """
    print('hey boy')

 输出方式:
     函数名.__doc__
     fun.__doc__
     print.__doc__
     
     
     
  demo1:
  def fun():
    """
    这是一个测试函数
    我是一个文档字符串
    我可以被输出
    :return:
    """
    print('hey boy')
 print(fun.__doc__)

结果：
'''
    这是一个测试函数
    我是一个文档字符串
    我可以被输出
    :return:
'''

  demo2:
  def tune(a, b):
   	 """
    	python基础  三器 装饰器 生成器  迭代器   一闭  闭包
    	"""
 return a + b

tune(1, 2)
print(tune.__doc__)  #    python基础  三器 装饰器 生成器  迭代器   一闭  闭包
print(tune(3,5))  # 8

核心作用就是查看函数的说明文档(文档尽量简洁,描述本质作用): 1.函数的作用
2.函数参数的作用 3.函数返回值的作用

作业

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
100
101
102
103
104
105
106
107
108
109
110
111
112
113

- 用函数写一个自我介绍功能 
  - 获取用户输入的数据，并且打印出来  
  - 格式为  我是 xxx  年龄：20    身高 ：180   样貌：帅
  - 姓名，年龄，身高，样貌
- 接受n个数字，求这些数字的和 
- 写函数，检查传入形参的长度，如果长度大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者 
- 写一个函数，根据 传入的是形参 是字符串类型 提取出形参 中所有奇数位上的字符 不是则提示错误 
- 写一个函数， 获取列表中的成绩的平均值，和最高分   如果不是 那就提示错误 
  - 例如   li = [123,1314,520]
- 修改猜拳小游戏修复bug，并且程序一直执行，除非玩家胜出，程序才会结束

"""
- 用函数写一个自我介绍功能
  - 获取用户输入的数据，并且打印出来
  - 格式为  我是 xxx  年龄：20    身高 ：180   样貌：帅
  - 姓名，年龄，身高，样貌

"""
# def induction():
#     try:# 捕获异常
#         name = input("请输入姓名： ")
#         age = int(input("请输入年龄："))
#         height = float(input("请输入身高："))
#         ap = input("请输入样貌：")
#         print(f"我是 {name}  年龄：{age}    身高 ：{height}   样貌：{ap}")
#     except Exception as e:  # 这里处理异常
#         print(e)  # invalid literal for int() with base 10: 'jk'
#         print("输入错误！---------")

# induction()

# - 接受n个数字，求这些数字的和
def summ1(*args):
    a = sum(args)
    print(a)
    return a

summ1(1,2,2,3,4,5,6,7,8,999)  # 1037

# - 写函数，检查传入形参的长度，如果长度大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者

# def check(li1):
#     if len(li1) > 2:
#         return li1[0:2]
#     else:
#         print("传入形参的长度小于2")
#
# # li1 = ["wk","md",1456]  # ['wk', 'md']
# li1 = ["wk","md"] # 传入形参的长度小于2  函数没有返回值  默认返回None
# # rest = check(li1)
# print(check(li1))


# - 写一个函数，根据 传入的形参 是字符串类型 提取出形参中所有奇数位上的字符 不是则提示错误
def fun(li):
    if type(li) is str:
        str1 = []
        for i in range(1,len(li),2):
            str1.append(li[i])
        print(" ".join(str1))   # a m m
    else:
        print("传入的形参不是字符串！")

fun("yanmomo")
# - 写一个函数， 获取列表中的成绩的平均值，和最高分   如果不是 那就提示错误
#   - 例如   li = [123,1314,520]

def fun3(li):
    if type(li) == list:
        num = 0
        for i in li:
            num += i
            avg = num/len(li)
        print('成绩平均值：',avg)   # 成绩平均值： 123.0
        print('最高分：',max(li))  # 最高分： 123
    else:
        print("输入数据不是列表")

li = [123,123]
fun3(li)


# - 修改猜拳小游戏修复bug，并且程序一直执行，除非玩家胜出，程序才会结束

import random

while True:
    try:
        player = input('请输入：剪刀(0)  石头(1)  布(2):')
        player = int(player)
    except Exception as e:
        print(e)
        print("输入错误！请重新输入！")
        continue

    # 产生随机整数：0、1、2 中的某一个
    computer = random.randint(0, 2)
    print(computer)
    # 用来进行测试
    # print('player=%d,computer=%d',(player,computer))

    if ((player == 0) and (computer == 2)) or ((player == 1) and (computer == 0)) or (
            (player == 2) and (computer == 1)):
        print('获胜，哈哈，你太厉害了')
    elif player == computer:
        print('平局，要不再来一局')
    else:
        print('输了，不要走，洗洗手接着来，决战到天亮')




个人推荐：

程序员工具网

代码可视化网站

三.函数作用域与名称空间

上节回顾

函数 >> 就是通过专门的代码，实现特定的功能

​ 定义 函数， 封装一些功能

​ 使用函数：>> 调用函数的功能

参数

  • 形参 ：函数定义时小括号里的变量就是形参
  • 实参 ：函数使用时小括号里传递的变量，对象，数据
  • return 把要返回的数据 放在return 后面 # 结束函数
1
2
3
4
5
6
7
8
9
10
11
12
def fun1():
    print("我是 函数") 

    
fun1()
# 有参数有返回值的函数
def fun2(a,b):  #  a,b   形参
    if a >1:
    	return a + b 

rest = fun2(1,2)       # 1,2    实参 
print(rest) # fun2 函数的返回值

参数进阶：

  • 默认参数 : 就是给参数一个默认值

    1
    2
    3
    4
    5
    def an(a,b=12):
        print(a,b)

    an(123,123)    
    an(123)

  • 可变参数 可以接收多个参数，*args 数据类型 类型为元组

    1
    2
    3
    4
    5
    def fun2(*args):
        print(args)  # 元组 类型
    	
    fun2(123,123,12,3,21,1,1,2,32,)
    fun2({"dsfds":dfdsfds},12)

  • 关键字参数 可以接收多个参数，**kwargs 数据类型 类型为字典

    1
    2
    3
    4
    5
    def fun3(**kwargs):
        print(kwargs)
        
    fun3(**{"ke":"le","age": 123})  
    fun3(name="韦小宝", height=123)

文档字符串

就是函数的说明书，可以打印出来

1
2
3
4
5
6
7
8
def fun1():
    """
    作用：
    文档字符串
    """
    print("文档字符串")
    
print(fun1.__doc__)

初始函数对象

​ 函数，非常重要 ，

​ 函数，非常重要 ，

​ 函数，非常重要 ， 但是有句话叫做通过表象，看本质

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
函数，就是一个高级的数据容器， 
1. 函数可以被引用   函数也可以赋值
def test():
    print(1314)
a = test  #  a 指向这个函数
a()       #调用a也可以运行这个函数

2. 函数可以作为元素，放到字典。集合，元组，列表
def test():
    print("test 函数")
    
func_dict = {"test": test}  # 函数test作为元素放到了字典中
func_dict["test"]()   # 运行后：test 函数   （）表示调用这个函数


3. 函数作为参数，传给别的函数
def test(a, b):
    print(a, b)  # 1 2


def my_func(x, y, func):
    return func(x, y)


rest = my_func(1, 2, test)  #1 2     全局名称空间
print(rest)  # None 因为
    
    
    
4. 函数也可以作为返回值
def test3(a,b):  # a ,b 局部变量
    print(a,b)

def my_func():   # 全局名称空间
    return test3  # 加括号 调用函数 没括号就是函数对象

test = my_func()
test(1,2)   # 1 2

名称空间

名称空间 >> 用来存储名字的地方

变量名 ， 函数名

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
程序中有专门的一些内存区域,来存储对应的数据
        名称空间 --> 存储变量名,函数名
        内存数据 --> 变量值,函数代码
    有一个东西,叫'名称空间'.它就是专门用来存名字的地方.它一共有三层结构
 
    1.内建名称空间(存内置函数)
        生命周期: 随着python程序启动而生成,在程序关闭时回收.清除所有数据
        加载顺序: 最先被加载出来的
        存放对象: 内置函数print input type sum len
    2.全局名称空间(存在python外层的名字)
        生命周期: 随着python程序启动而生成,在程序关闭时回收.清除所有数据
        加载顺序: 第二个被加载出来的
        存放对象: 在python外层写的代码,定义的变量名,函数名
    3.局部名称空间(存在函数内定义的名字)
        生命周期: 随着函数的调用而生成,在结束调用时销毁
        加载顺序: 在调用时才会被加载
        存放对象: 在函数里定义的变量名,函数名,形参
            

1. 名称空间的加载顺序
   1. 内置名称空间>全局名称空间>局部名称空间
2. 销毁顺序
   1. 局部名称空间>全局名称空间>内置名称空间
3. 名字的查找优先级
   1. 当前所在的位置向上一层一层查找,查找一个名字，必须从三个名称空间之一找到，查找顺序为：局部名称空间->全局名称空间->内置名称空间
    
       
a,b=11,22
def my_func2():
    print(a,b)

my_func2()   # 11 22

小结：

一个程序里的数据，是有专门的地方的存储的

名称空间 >> 专门又来存储名字的地方

作用域

作用域：一个数据能够使用的范围

wifi：一个WiFi能够使用的范围、

全局作用域和局部作用域

1
2
3
4
5
6
7
8
9
全局作用域: 整个程序里都可以使用
       (内建名称空间,全局名称空间)
       内置函数,在外层定义的变量,函数名
   公共wifi: 所有人都可以连的wifi

   局部作用域 = 只有在局部位置才能使用(函数内)
       局部名称空间
       函数里面定义的变量和函数名
   公司wifi: 只有公司里的人才可以连接

作用域与名字查找的优先级

在局部作用域查找名字时，起始位置是局部作用域，所以先查找局部名称空间，没有找到，再去全局作用域查找：先查找全局名称空间，没有找到，再查找内置名称空间，最后都没有找到就会抛出异常

在局部作用域查找时 >> 局部作用域(局部名称空间) >> 全局作用域（全局名称空间） >> 内置名称空间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
x = 100 # 全局作用域的名字 x
def foo():
    x = 300 # 局部作用域的名字 x
    print(x) #在局部找x  300
foo()#结果为300
 
在全局作用域查找名字时，起始位置便是全局作用域，所以先查找全局名称空间，没有找到，再查找内置名称空间，最后都没有找到就会抛出异常

全局作用域（全局名称空间） >>>  内置名称空间

x = 100
def foo():
    x = 300 #在函数调用时产生局部作用域的名字 x
foo()
print(x) #在全局找x, 结果为 100

提示：可以调用内建函数locals()和globals()来分别查看局部作用域和全局作用域的名字，查看的结果都是字典格式。在全局作用域查看到的locals()的结果等于globals()

函数嵌套

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Python支持函数的嵌套定义，在内嵌的函数内查找名字时，会优先查找自己局部作用域的名字，然后由内而外一层层查找外部嵌套函数定义的作用域，没有找到，则查找全局作用域
 

x=1
def outer():
    global x=2
    def inner(): # 函数名inner属于outer这一层作用域的名字
        x=3
        print('inner x:%s' %x)  # 
 
    inner()
    print('outer x:%s' %x)  # 
 
outer() 
print(x) # 2 
#结果为
inner x:3
outer x:2

在函数内，无论嵌套多少层，都可以查看到全局作用域的名字，若要在函数内修改全局名称空间中名字的值，当值为不可变类型时，则需要用到global关键字 

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
    如果要提权 -- 让一个数据,从局部变成全局 -- global
    global = 全局 = 大方的人,让所有人都可以使用
 	
    变量名 = 数据
    def 函数名():
        gloabl 变量名
        操作变量
    函数名()
    print(变量)
 	
    name = "韦小宝"
    def fun():
        global name
        name = '韦寻'
    fun()
    print(name)
    # 要使用函数里的变量,除了要给他global提权外,还需要调用函数,才能生成对应的名称空间
 
    nonlocal -- 非公有 -- 让一个代码,变成你专属的 -- nonlocal
    在公司里有个wifi --> 公司里的人都可以使用,外面的人用不了
    我想办法霸占了这个wifi,让它只能我一个人连
 
    nonlocal = 非公有 = 小气的人,原本大家都能用,但是现在只有我能用
 
    def fun1():
        a = 520 # 这个a,从在函数里的角度说,是公有的,函数里的大家都能使用
        def fun2():
            nonlocal a # 把变量a,抢过来,私有化. 从此以后它归老子管
            a = 99
        fun2()
        print(a)
     
    fun1()
    
    
# nonlocal a会从当前函数的外层函数开始一层层去查找名字a，若是一直到最外层函数都找不到，则会抛出异常

小结：

在函数内部，要想修改全局变量， 就用 global 进行提权

并且要执行函数才能生效

匿名函数 lambda函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
http://c.biancheng.net/view/2262.html
 
省略函数名 --> 如果你要用一个函数,但是不想给她取名字,那就用lambda表达式.可以不取名字使用函数
 
原来的写法:
def add(a,b):
    return a+b
print(add(70,47))
 
现在的写法
add = lambda a,b:a+b
print(add(70,47))
 
语法格式:
lambda 变量:操作
lamdba a:print(a)
 
talk = lambda a:print(a)
talk('小包，小宝')

作业

填空题：

  1. 输入函数 ：（input ）输出（print ）
  2. 序列类型和散列类型的区别是_有序 可以 用 下标 切片 的方式取出数据 ，，无序， 不会存重复的数据_
  3. 字典是用__键值对_的方式来存储值
  4. 分支语句分为三种,分别是 单分支__ , 双分支 和_多分支_ 分支语句的结构代码也是三种,分别是 ( if),(if…else),( if…elif…else)
  5. 有一个循环,我还没想好里面要写啥,但是先声明下来.我应该在循环内写上 pass__避免报错
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
if xxxx:
    print()
    # 代码块
else:
    # 代码块
    
    
if xxxx:
    print()
    # 代码块
elif xxx:
    # 代码块
   
else:
    # 代码块

因为try 这个是高级编程

解答题：

  1. 变量名，函数名的命名规则有哪些？

    1
    2
    3
    4
    ``由数字,字母,下划线组成
    ``2.不能数字开头,不能有别的特殊符号
    ``3.大驼峰，小驼峰,不要用关键字
    ``4.见名知意

  2. 查看变量类型的Python内置函数是 

    1
    type(变量名)
  3. 名称空间有三种,分别是?分别是存储啥?
  ``内建名称空间 --> 存储内置函数
  ``全局名称空间 --> 在外层存储定义的变量,函数名
  ``局部名称空间 --> 存储函数内定义的变量,函数名

    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

    4. 序列类型的下标是从几开始?
       0

    5. 在循环语句中，什么语句跳过本层循环  ？ 什么语句结束循环   ？

       continue，break

    代码题：（函数方式）

    1. 字符串str1 =  “韦小宝ppd”

       1. 切片取出 "韦小宝"

          `str1=str1[0:3] `

          1. 通过方法ppd变成 Python

          `str1 = str1.replace("ppd", "Python")`

       2. 获取字符串长度

          `len(str1)`

          ```python
          str1 =  "韦小宝ppd"  # 作为全局变量
          def test_str():
              # 对str1 进行操作
              # 1. 切片取出 "韦小宝"
              index = str1.find("韦小宝") # 找到下标  找不到 -1
              # 0 
              rest = str1[index:index+3]
              print(rest)
              
              # 通过方法  ppd 变成 Python
              print(str1.replace("ppd", "Python"))
              #  如果没写参数3 是全部替换
              
              # 获取字符串长度
              print(len(str1))
              
          test_str()
              
          str1 = "韦小宝ppd"  # 作为全局变量

          """进行 升级  写上形参  并且bug 修复  完善 它 """
          def test_str(str3):
              if type(str3) is str:
                  # 对str3 进行操作
                  # 1. 切片取出 "韦小宝"
                  index = str3.find("韦小宝")  # 找到下标  找不到 -1
                  # index 0 
                  rest = str3[index:index + 3]  # [0:3]
                  print(rest)
                  # 通过方法  ppd 变成 Python
                  print(str3.replace("ppd", "Python"))
                  # 获取字符串长度
                  print(len(str3))
              else:
                  print("传入数据类型错误")
                  
          test_str(["sdfdsa"])

          # try 可以捕获一切的异常
    

   ​

  4. 用列表，存入你的成绩 成绩类型为元组（12,23,99,230）

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
score = (12,23,99,230)
li1 = []  # 空的列表 
def test_list():
    # for i in 字符串，列表 元组，
    for i in score:
        li1.append(i)   # 添加append方法 会把数据添加到数据最后面
    print(li1)

test_list()

""" 升级 """
def test_list(re_score, li):
    num1 = 1000  # 从函数调用 属于局部 
   	if type(re_score) == tuple and type(li) == list:
        # print(list(re_score))
        # for i in 字符串，列表 元组，
        for i in re_score:
            li.append(i)   # 添加append方法
        print(li)
    
    def test_li2(num): # 局部函数
        print("内部函数", num)

    test_li2(num1)  # 从这里看 num1 全局
    
test_list(score, li1)

  1. 累加10 – 60之间,个位不是3/5/8的整数和。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    def test_num():
        
        sum_value = 0  # 用这个存储整数和
        for number in range(10, 61):
            # 60 % 10 = 0
            unit = number % 10   # 求个位上的数  % 取余 
            if unit == 3 or unit == 5 or unit == 8:
                continue         # continue 跳过循环
            sum_value += number
        print(sum_value)
        
    test_num()

  2. 将列表中的数字累乘

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    list01 = [5, 1, 4, 6, 7, 4, 6, 8, 5]
    # 结果：806400
    def mxo():
    	result = 1  # 因为1乘以任何数字,都不改变.
        for x in list01:
            result *= x
            # result = result * x
        print(result)
        
    mxo()

  3. ```python

    打印出来一下图形

    “””

    • **

    “””
    i = 1
    while i <= 5:
    while j <=i:
    print(“*”,end=””)
    j +=1
    print(“\n”)
    i+=1

    def xingxing():
    for i in range(1,6):
    print(“*”*i)
    xingxing()

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23

    3. 用函数定义 一个计算 两个数 功能

       ```python'
       def sum1(a, b):
           flag = int(input("输入 加法（1）减法（2）乘法（3）除法（4）"))
           if flag == 1:
               return a + b
           elif flag == 2:
               return a - b
        elif flag == 3:
               return a * b
           elif flag == 4:
               return a / b
           else:
               print("提示 用户输入错误")

       print("欢迎使用Python 计算机")
       num1 = int(input("请输入第一个数  "))
       num2 = int(input("请输入第二个数  "))

       rest = sum1(num1, num2)
       print("计算后的结果",rest)

    7.用函数完成 集合练习

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #一家公司有如下岗位：
    # 经理 ："曹操","刘备","孙权"
    # 技术 ："曹操","刘备","张飞","关羽"
    def test():
        #使用集合存储以上信息
        mag = {"曹操","刘备","孙权"}
        tec = {"曹操","刘备","张飞","关羽"}
        # 是经理也是技术的都有谁?
        print("是经理也是技术的都有谁")
        print(mag & tec)  # 交集 
        #是经理也不是技术的都有谁?
        print(mag - tec)  # 差集
        #不是经理是技术的都有谁?
        print(tec - mag)
        #身兼一职的都有谁?
        print(tec ^ mag)  # 对称差集  返回各自独有的
        #公司总共有多少人数?
        print(len(tec | mag))  # 并集 返回长度
        
      
    test()

四.复习拓展

作业讲解&&复习 这种方式老师觉得更适合你们

pycharm的debug的使用

扩展

操作系统

手机操作系统 安卓（开源，小工具），ios (封闭，闭环)，鸿蒙（华为）（打破垄断，自己的生态，信息安全），

电脑操作系统：Mac，win linux （开发服务器，项目上线 ）

1
2
3
大前提：我们编程的目的就是控制电脑，让电脑硬件自发的运行起来，毕竟硬件是死的

硬件的运行都是有软件支配的

我想开发 一个软件 网易云音乐 》》 音响，屏幕 调用其他东西

网易云音乐 ： 应用程序

通用的软件： 操作系统

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
网易云音乐（音乐软件）
控制程序（操作系统）
	1. 控制计算机硬件的基本运行
    2. 把硬件运行的复杂操作封装成简单的功能，给上层的应用程序使用
计算机硬件

操作系统是一个协调，管理，控制计算机硬件资源和应用软件资源的一个控制程序

作用：
	1.控制计算机硬件的基本运行
    2.把使用硬件的复杂操作封装成简单的功能，给上层的应用程序使用
    比如：
    	文件就是操作系统提供给应用程序/用户操作硬盘的一种功能
        
文件扩展名也称为文件的后缀名，时操作系统用来标识文件类型的机制
让系统快速识别文件类型，然后交给相应的程序处理
扩展名几乎是每个文件必不可少的一部分
	如果一个文件没有扩展名，Windows操作系统就无法处理这个文件
    无法辨别到底如何处理该文件
    
    
程序的区别：
	计算机的硬件是死的，计算机的硬件的运行都受软件的控制，所以说软件是计算机的灵魂
    具体来说软件分为两种：
    	1.应用软件：应用程序相关的逻辑
        2.系统软件：控制底层硬件的    操作系统
    
延伸几个问题： 
    1.   没有操作系统可以吗？    某些特定的场景不一定用  取决实际情况      可以，但不是必须的   
    2.   我们以后写的是什么软件？应用软件
    3.   找准自己的用户定位   
    开发手机App   那用户是 手机用户    手机用户使用方式
 	
    
    
**平台** 
            应用程序都是运行于操作系统之上，而操作系统则是运行于硬件之上的，
            所以承载应用程序的是一台运行有操作系统的计算机，称之为应用程序的运行平台，
            即：硬件 + 操作系统 == 平台
 
            软件的跨平台性是指：一款软件可以在任意平台上运行，是衡量软件质量高低的一个非常重要的指标
 
 

windows   可视化界面  鼠标    一个月不关机  卡的 要死   一周关机一次
 
玩游戏    服务器linux    服务器不能轻易的关机   你上网就是访问别人的电脑      
跨平台  在其他的平台上，可以几乎不改动代码，也能正常运行


内功  》》  看能力  空间复杂度，
没有任何一个语言可以在领域，做到统治

python  #  看能力  能力强， 说不定 你就是 某大厂的 产品 技术人员
Rust    #  也是作为系统开发语言  并且 已经 被Linux 开源 同意 它进入

赏

谢谢你请我吃糖果

支付宝
微信
置顶

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家