Python 快速入门

时间:2020-8-17 作者:admin


Python 快速入门学习

1. python的基本语法

1.1 变量

变量:内存中存储空间的一个表示

1.12 如何定义变量

例如:
a = 5
b = “你好”

1.13 输出一个变量

print(a)
print(b)

\t表示缩进,相当于按Tab的效果(4个空格),\n表示换行

1.14 变量的数据类型

整数 int 
浮点型 float 
字符串 str 字符串可以使用单引号,双引号,3个双引号定义 
布尔 bool

=表示赋值,==表示判断是否相等
例如:

a = 5       #整形
b = "你好"       #字符串
c = 5.20          #浮点型
d = True         #布尔类型

print("a的数据类型是:",type(a))
print("b的数据类型是:",type(b))
print("c的数据类型是:",type(c)) 
print("d的数据类型是:",type(d))

1.15 变量的运算

1,字符串可以和字符串做加法运算

s1 = "12" 
s2 = "3"
s = s1 + s2
print("结果是:",s)
#结果是:123

2,字符串可以和整形做乘法运算

s = "好好学习\t" 
n = 10 
jieguo = s * n 
print("结果是:"jieguo)
#结果是:好好学习	好好学习	好好学习	好好学习	好好学习	好好学习	好好学习	好好学习	好好学习	好好学习

3,数值型可以和数值型做所有的算数运算

n1 = 7 
n2 = 3 
j1 = n1 + n2 
j2 = n1 - n2 
j3 = n1 * n2 
j4 = n1 / n2 
j5 = n1 % n2
j6 = n1 // n2 
j7 = n1 ** n2 
print("n1和n2相加的结果为:",j1) 
print("n1和n2相减的结果为:",j2) 
print("n1和n2相乘的结果为:",j3) 
print("n1和n2相除的结果为:",j4) 
print("n1和n2求余数的结果为:",j5)
print("n1和n2取整结果为:",j6) 
print("n1和n2求幂的结果为:",j7)

#结果:
n1和n2相加的结果为: 10
n1和n2相减的结果为: 4
n1和n2相乘的结果为: 21
n1和n2相除的结果为: 2.3333333333333335
n1和n2求余数的结果为: 1
n1和n2取整结果为: 2
n1和n2求幂的结果为: 343

1.16 变量的输入

s = input("请在控制台输入一个东西:") 

print(type(s))      #不管输入的什么类型,默认都是字符串类型 

print("输入的这个变量是:",s)

1.17 变量的类型转换

n = int(str) #将字符串类型转换为整数类型 
f = float(str) #将字符串类型转换为小数类型

 # 实现一个2个数的加法计算器 
 n1 = input("请输入第一个数:")
 n2 = input("请输入第二个数:") 
 print('n1的类型是:',type(n1)) 
 num1 = int(n1)    #将n1转换为整形
 num2 = int(n2) 
 print('num1的类型是:',type(num1)) 
 result = num1 + num2 print("相加的结果为:",result)

例如:

小明去超市购物: 价格如下:口罩:3.5一个 荔枝:12元一斤 猪肉 :26元一斤 小明购买了3个口罩,2斤荔枝,半斤猪肉。
结账的时候,老板宣布所有商品全部打8折。请编写程序计算最终 的应付款 :

kouzhao = 3.5 #定义一个口罩,单价是3.5一个 
lizhi = 12 #定义荔枝,12元一斤 
zhurou = 26 #定义猪肉,26一斤 
money = kouzhao * 3 + lizhi * 2 + zhurou * 0.5 
print("应付金额为:",money) 
shiji = money * 0.8 print("实际应付金额为:",shiji)

1.18 变量的格式化输出

%s 表示字符串
%d表示整形
%f 表示小数

%s格式化输出
s = “我的名字叫%s,今天:%d岁,身高%.2f” % (name,age,height)

例如:# 1,定义姓名,年龄,身高这3个变量,采用格式化输出 这样一句话“我的名字叫xx,今年xx岁,有xx米高” 
# xx为变量值

#%s格式化输出 
s = "我的名字叫%s,今天:%d岁,身高%.2f" % (name,age,height)

#format格式化输出
s = “我的名字叫{},今天:{}岁,身高{:.1f}”.format(name,age,height)

#format格式化输出 
s = "我的名字叫{},今天:{}岁,身高{:.1f}".format(name,age,height)

2. 逻辑判断(分支结构)

2.1 单个分支结构

if 表示如果
else 表示否则

例如:如果分数超过60分,那么就及格了,如果分数低于60分,那么就不及格
score = int(input("请输入你的成绩:")) 
if score >= 60: 
	print("及格") 
else:
	print("不及格")

2.2 多个分支结构

elif 表示不满足if里面的条件的前提下判断是否满足当前这个条件

例如:如果分数超过60分,那么就及格了,如果分数低于60分,如果分数超过80分,输出优秀,那么就不及
格
score = int(input("请输入你的成绩:")) 
if score >= 80: 
	print("优秀") 
elif score >= 60:     #只有当分数低于80分的时候,程序才会判断这个条件 
	print("及格") 
else:
	print("不及格")

2.3 逻辑运算符

and 表示并且 
or 表示或者 
not/! 表示取反

2.31 and 用法

例如:如果语法成绩和数学成绩全部大于60分,输出批准毕业,如果有一门低于60分,都输出不能毕业
yuwen = int(input("请输入语文成绩:")) 
shuxue = int(input("请输入数学成绩:")) 
if yuwen >= 60 and shuxue >= 60: 
	print("可以毕业") 
else:
	print("不能毕业")

2.32 or 用法

例如:如果语文和数学有一门是满分,就可以毕业,否则就不能毕业
yuwen = int(input("请输入语文成绩:")) 
shuxue = int(input("请输入数学成绩:")) 
if yuwen == 100 or shuxue == 100: 
	print("可以毕业") 
else:
	print("不能毕业")

2.33 not 用法

例如:如果语文成绩不低于60分或者数学成绩不低于60分就可以毕业
yuwen = int(input("请输入语文成绩:")) 
shuxue = int(input("请输入数学成绩:")) 
if not(yuwen < 60) or not(shuxue < 60): 
	print("可以毕业") 
else:
	print("不能毕业")

2.4 逻辑嵌套

在if的里面或者在else的里面继续判断

例如:
username = input("请输入用户名:") 
password = input("请输入密码:") 
if username == "admin":#表示用户名输入正确 
		if password == "123": 
				print("登录成功") 
		else:
				print("密码错误") 
else:#表示用户名输入错误 
		if password == "123": 
				print("用户名错误,密码正确") 
		else:
				print("用户名和密码都错误")
例2:逻辑判断练习题:
小明去超市购物:
价格如下:口罩:3.5一个 荔枝:12元一斤 猪肉 :26元一斤
小明购买了x个口罩,y斤荔枝,z斤猪肉。结账的时候,老板说有会员的用户如果商品金额大于200元打
六折,金额不足200元也可以打8折。没有会员的用户,金额大于200块,打9折,不足200块,不打折原
价支付。
程序:
输入:是否是会员,购买金额
输出:最终的实际支付金额

n1 = int(input("口罩要几个:")) 
n2 = float(input("荔枝来几斤:")) 
n3 = float(input("猪肉来几斤:")) 

kouzhao = 3.5 #定义一个口罩,单价是3.5一个 
lizhi = 12 #定义荔枝,12元一斤 
zhurou = 26 #定义猪肉,26一斤 

money = kouzhao * n1 + lizhi * n2 + zhurou * n3 
print("购物金额是:{}元".format(money)) 

vip = input("请问是会员吗?(Y/N)") 
if vip == "Y": #是会员 
		if money >= 200: 
				m = money * 0.6   #是会员并且购买金额超过200  打6折
		else:
				m = money * 0.8   #是会员并且购买金额不超过200  打8折
else: #不是会员 
		if money >= 200: 
				m = money * 0.9 
			
print("实际付款{}元".format(m))

3. 循环

3.1 循环的定义

重复的去执行一行或者多行代码

3.2 while 循环的语法

i = 1
while i < 5:
	 print("好好学习") 
	 i = i+1 #加法的运算优先级高于=号,所以i = i + 1,先将i+1的值赋值给i本身 
print("结束了")

#结果:
好好学习
好好学习
好好学习
好好学习
结束了

3.21 while 循环实现累加

在while循环的里面放多行代码 
i = 6 
#再定义一个变量,这个变量的作用就是存钱罐(容器) 
sum = 0 
while i <= 13: 
		sum = sum + i 
		i += 1 
print("整数之和为:{}".format(sum))

#结果:
整数之和为:76
例2:
 假设黄金的日涨幅为0.8%(只涨不跌),现在买了1万块的黄金,问经过多少天,本金可以变成10万。
day = 0 
money = 10000  
while money <= 100000: 
		money = money * 0.008 + money 
		day += 1 
print("需要{}天,达到10万".format(day)) 

#结果:
需要289天,达到10万

3.22 while 里面的 break 用法

break 表示跳出循环,不管是否满足循环条件,只要碰到break循环就会终止

i = 1 
while i <= 10:
		 if i == 3: 
		 break 
		 print("好好学习") 
		 i += 1 
print("循环结束了") 

#输出结果为:2次好好学习
# 练习题:
循环输入整数,按q退出。循环结束后可以将所有整数相乘并输出结果
result = 1 
while True: 
		n = int(input("请输入整数:")) 
		result *= n 
		s = input("按任意键继续(q退出):")
		if s == "q": 
		 		print("循环结束!") 
		 		break 
print("乘积为:{}".format(result))

3.23 while 里面的 continue 用法

continue 表示跳过当前这次循环,来到下一次循环

#实现1到5之间的所有整数之和 
i = 1 sum = 0 
while i <= 5:
	 if i == 3: 
	 	i += 1 
	 	continue #3不会累加 
	 else:
	 	sum += i 
	 	i += 1 
print("1到5之间的所有整数之和为:{}".format(sum))

3.3 循环嵌套

在循环的里面嵌套一个循环

#九九乘法表就是一个很好的嵌套循环例子
i = 1
while i <= 9:
    j = 1
    while j <= i:
        print("{}x{}={}".format(j,i,i*j), end=" \t")
        j +=1
    print()
    i +=1

#结果:
1x1=1 	
1x2=2 	2x2=4 	
1x3=3 	2x3=6 	3x3=9 	
1x4=4 	2x4=8 	3x4=12 	4x4=16 	
1x5=5 	2x5=10 	3x5=15 	4x5=20 	5x5=25 	
1x6=6 	2x6=12 	3x6=18 	4x6=24 	5x6=30 	6x6=36 	
1x7=7 	2x7=14 	3x7=21 	4x7=28 	5x7=35 	6x7=42 	7x7=49 	
1x8=8 	2x8=16 	3x8=24 	4x8=32 	5x8=40 	6x8=48 	7x8=56 	8x8=64 	
1x9=9 	2x9=18 	3x9=27 	4x9=36 	5x9=45 	6x9=54 	7x9=63 	8x9=72 	9x9=81 

4. 容器

字符串的之类是str,列表的类型是list,元组的类型是tuple,字典的类型是dict,set集合的类型是set

4.1 字符串

4.11 字符串的概念

字符串可以由单引号,双引号,3个双引号定义。字符串是一个序列化容器。
序列化指的是元素连续排列,有 下标,支持索引和切片。
非序列化没有下标,不支持索引和切片

4.12 字符串通过下标访问对应的元素

下标都是从0开始!!!

s = "好好学习" 
s1 = s[0] #如果下标不存在,会报索引越界异常 
s2 = s[1] 
print(s1) 
print(s2)

4.13 字符串的遍历

c = len(s) 
print("字符串的长度为:{}".format(c)) 
str = "好好学习,拒当备胎" 
print("while循环遍历的结果为:") 
i = 0 
while i < 9: 
		print(str[i],end=" ") 
		i += 1 

##for循环遍历
print("\nfor循环遍历的结果为:") 
for s in str:
	 print(s,end=" ")

输入一个字符串:明天会更好。逆序输出,输出的是好更会天明
str = input("请输入一句话:") 
i= len(str)-1             #利用while循环 算出总长度 再倒序输出
while i >= 0: 
	print(str[i],end=" ")
	i -= 1

4.14 字符串的常用API

4.141 字符串的替换

str = "一存光阴一存金,存金难买存光阴"
str2 = str.replace("存","寸",2) #有3个参数,第一个参数是旧元素,第二个参数是新元素,第三个 参数是替换的数量 
print(str2)

4.142 字符串的查找

str = "一存光阴一存金,存金难买存光阴" 
index = str.find("光") #当要查找的元素不存在的时候,不会报错,只是会返回-1 

index2 = str.rfind("光")              #rfind逆序查找
print("最左边的光的下标为:",index) 
print("最右边的光的下标为:",index2)

4.143 字符串的切片

str = "www.7k7k.com" 
s1 = str[:3] #字符串切片,包头不包尾,切出www 
s2 = str[4:8] #切出7k7k 
s3 = str[9:] #切出com 

str = "www.7k7k12345678987654321.com" 
#切出com 
s = str[-3:] #从右往左 
print(s)
例如:编写一个文件检测的脚本:规定后缀名为py或者是java的文件可以通过检测。
其他后缀名的文件不能通过检测。满足条件输出检测通过,不满足条件就输出未通过检测

while True: 
	text = input("请输入文件名:") 
	index = text.rfind(".") #查找文件名中最后一个小数点的下标
	if index != -1 and index > 0:
		 houzhui = text[index+1:] 
		 print("后缀名是:",houzhui) 
		 if houzhui == "py" or houzhui == "java":
		 	 print("通过检测") 
		 else:
		 	 print("未通过检测") 
	 else:
	 	 print("没有后缀或者文件名为空,请重新输入!")

扩展 判断字符串是否是数字

str = "12o3" 
b = str.isnumeric() #如果字符串中所有的字符都为阿拉伯数字,返回True 
print(b)

扩展 判断字符串是否为字母

str = "Aabc" 
b = str.isalpha() #当字符串中只有纯字母的时候返回True 
print(b)
运用:
用户名格式校验:要求用户名不能全部是字母,用户名不能全部是数字,用户名不能含有除字母和数字
以外的符号,也就是说用户名必须是字母和数字的组合(要用所学过的方法编码)
用户名符合条件即输出注册成功,否则输出用户名不符合格式要求

while True:
username = input("请输入用户名:") 
 
zm = 0        #定义一个统计字母个数的变量
sz = 0       #定义一个统计字母个数的变量

for u in username:
	 if u.isalpha() == True: #说明该字符是字母 
		 zm += 1 
	 elif u.isnumeric() == True:#说明该字符是数字 
	 	sz += 1 
	 	
	if zm + sz == len(username) and username.isalpha() == False and username.isnumeric() == False:
	 	 print("用户名符合格式要求") 
	else:
	  	 print("不符合")
 

4.2 列表

4.21 列表和数组的区别

python中的列表跟java里面的数组非常类似,但是也有区别:
1,python中的列表长度可以变的
2,python的中的列表可以存放不同数据类型的数据

list = [3,"你好",9,"张三"] #可以存放不同的数据类型 
print(list)

4.22 列表添加元素

list = [3,"你好",9,"张三"] 
list.append(6) #列表的长度可以变,可以直接向列表中添加元素 
print(list)

4.23 列表删除元素

list = [3,"你好",9,"张三"] 
list.remove("你好") #remove表示根据元素去删除 
print(list)

list = [3,"你好",9,"张三"] 
list.pop(3) #pop表示根据下标去删除 
print(list)

4.24 列表查找元素的下标

list = [3,6,1,9] 
xiabiao = list.index(6) 
print("6的下标是:{}",xiabiao)

4.25 列表修改元素

list = [3,6,1,9] 
xiabiao = list.index(6) 
print("6的下标是:{}",xiabiao) 

#将列表中的6替换为66 
list[xiabiao] = 66 #根据下标去修改元素 
print("修改后的列表为:",list)

4.26 列表的排序

list = [3,6,1,9,5,7] 
list.sort() #列表中排序的方法,默认是从小到大 
print("排序后:",list)

#结果是
1,3,5,6,7,9
list = [3,6,1,9,5,7] 
list.sort(reverse=True) #列表中排序的方法,从大到小 
print("排序后:",list)

#结果是
9,7,6,5,3,1

5. 元组

列表支持增删改查所有操作,元组只支持查询操作,不支持修改,删除,添加
元组的好处:1,防止误操作而引起的数据变动。2,节省内存空间。
元组是一个序列化容器,支持索引和切片

5.11 元组的定义

names = ("张三","李四","王五")
 如果元组只有一个元素,那么末尾一定要加逗号。如果没有加逗号,那么数据类型就是str。 
 names = ("张三",) 
 print(type(names)) 

如果内元组只有一个元素,那么也要加上逗号 
nums = ((5,),) 
print(type(nums)) 

## for 嵌套循环遍历元组
for num in nums: 
	for n in num: 
		print(n,end=" ")

5.12 元组的应用

1,连接mysql数据库,查询数据的结果是元组类型
2,可变参数是通过元组存储参数的
3,多个返回值返回的结果是元组类型

5.13 元组不支持 增,删,改

元组是 没有增加,删除,更改的API  !!!

5.14 元组的遍历

names = ("张三","李四","王五") 
for name in names: 
	 print(name,end=" ") 
	 
nums = ((3,5),(9,4),(6,1,2),7) #嵌套元组的遍历 
for num in nums: 
	if type(num) == tuple: 
		for n in num: 
			print(n,end=" ")
	else:
		print(num,end=" ")`

5.15 元组的查询

names = ("张三","李四","王五") 
n = names[1] #根据下标去查询指定的元素 
print(n) 

xiabiao = names.index("王五") #根据元素去查找对应的下标 
print(xiabiao)

6. 字典

6.1 字典的概念

字典是一个非序列化容器,不支持索引和切片。元素与元素通过逗号相隔,
把一个元素拆分成键和值。不是通 过下标去查询元素,而是通过键去查询值

6.2 字典的定义

student = {"姓名":"张三","性别":"女","年龄":19} #直接定义了一个带有3个元素的字典 
student2 = {}    #定义一个空字典

6.3 字典添加元素

stu = {} 
stu["name"] = "张三"       #向字典中添加了一个键值为 name  的 张三元素
print(stu)

6.4 字典的元素修改

student = {"姓名":"张三","性别":"女","年龄":19} 
student["年龄"] = 20 
print(student) 

student.update(年龄=30) #通过关键字修改

当一个键不存在的时候,就是添加。存在的时候值会覆盖上一次的值

6.5 字典的查询

#查询学生的姓名
name=student.get("姓名2") 
#根据键去查询值,当键不存在的时候,返回None 
print(name) 

#查询学生的姓名 
name = student["姓名2"] #根据键去查询值,当键不存在的时候,会报错 
print(name)

6.6 字典的遍历

6.61 取所有的键和值

phone = {"Logo":"华为","type":"P30","price":3999,"neicun":"8G"} 

for k,v in phone.items():    #字典的遍历方法
	print("{}:{}".format(k,v))

6.62 取所有的键

例如:
k = phone.keys() 
for kk in k: 
	print(kk)

6.63 取所有的值

例如:
v = phone.values() 
	for vv in v: 
		print(vv)

6.64 嵌套字典

dict = {“键1”:{“键1”:“值”,”键2″:“值2”},“键2″:{“键1”:“值1”,“键2”:“值2”}}

嵌套字典的遍历

dict = {"键1":{"键1":"值1","键2":"值2"},"键2":{"键1":"值1","键2":"值2"}} 

for k,v in dict.items(): 
	print(k) 
	for kk,vv in v.items(): 
		print(kk,vv)

7. 函数

7.1 函数的概念

可以完成某个功能的一段代码,函数不调用不执行

7.2 函数的作用

1,提高代码的复用性
2,减少了项目的维护成本
3,多人开发,提高了开发效率

7.4 函数的定义

#函数名符合变量的命名规范 
#1,字母和数字和下划线,$的组合 
#2,变量的开头不能是数字 
#3,变量不能是关键字

例如:打印三角形的函数
def print_star():            #def关键字定义函数
	 """ 
	 打印三角形的函数 
 	入参:xx 
 	:return:null 
 	"""
 	 i = 1 
 	 while i <= 5: 
 	 	print("#" * i, end=" ") 
 	 	print() 
 	 	i += 1 

#调用函数 
print_star()

7.5 函数的调用

在当前文件中调用直接用函数名调用 
在其他文件中需要导包后调用 
from py_day02.人机猜拳 import * 
print_star

7.6 函数的参数

7.61 单个参数

#编写一个榨汁机的函数,这个函数可以榨果汁
def zzj():#函数没有参数意味着只能榨一种果汁 
	print("榨好了一杯西瓜汁") 
zzj() 


def zzj2(shuiguo):         #有参数后意味想喝什么果汁都可以 
	print("榨好了一杯{}汁".format(shuiguo)) 
	
while True:
	 sg = input("请问你想喝啥?") 
	 zzj2(sg)

7.62 多个参数

例如:
#完成2个任意之和 
def add2(num1,num2):
	 sum = num1 + num2 
	 print("结果是:{}".format(sum)) 

add2(3,4)

7.63 参数的总结

形参:在编写函数时定义的参数称之为是形参
实参:在调用函数的时候传入进去的参数称之为实参

形参和实参的关系:
1,形参和实参的个数必须要一样
2,形参和实参的数据类型必须要一样
3,形参和实参的位置顺序必须要一样

例如:
# 定义一个函数,要求:计算x到y之间所有的偶数之和。 

def sumOu(x,y): 
	sum = 0 
	i = x 
	while i <= y: 
		if i % 2 == 0: 
			sum += i 
		i += 1 
	print("偶数之和为:",sum) 

sumOu(2,7)   #调用函数并传入参数

7.7 函数的返回值 return

概念

后端工程师 -->编写接口,接口返回数据(JSON/xml) 
前端工程师 -->得到json数据解析,展示在网页上 一些常见的有返回值的函数:
比如 str = input("请输入:")#这里的str就是函数的返回值 

没有返回值的函数,有print语句的:只能打印在控制台,无法在其他地方使用函数加工后的成品 

有返回值的函数:调用函数的时候,可以得到该函数加工后的成品,至于我是打印还是传递到其他地方

7.71 单个返回值

例如:
# 实现2个数的相加函数 
def add(n1, n2): 
	sum = n1 + n2 
	return sum                     #返回sum的结果

result = add(3,7) 
print(result)

7.72 多个返回值

多个返回值需要用逗号隔开,调用多个返回值的函数会得到一个元组,
该元组中存储的就是函数的那多个返回值,遍历即可使用里面的返回值了

def computer(n1,n2):
	 sum = n1 + n2 
	 jian = n1 - n2 
	 return sum,jian     #返回sum跟jian的结果

j1 = computer(7,3) 
print(type(j1))      #多个返回值 是一个元组来存储
print(j1) 
for j in j1:      #利用for遍历出来
	print(j)

扩展 函数与返回值的应用场景

# 生成指定长度的验证码(由数字和大小写英文字母构成的随机字符串) 
# 就是说如果用户输入4,那么就生成一个4位数的随机验证码。 
# 用户输入5,就生成一个5位数的随机验证码... 
# 要求:编写函数完成。(返回验证码) 
import time 
def makeGode(length): 
	str = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" 
	import random 
	i = 1 
	code = "" 
	while i <= length: 
		r = random.randint(0,len(str)-1)     #利用随机数生成下标并获取对应的下标的字符串内容
		code += str[r]                                  #获取对应下标的字符串内容
		i += 1 
	return code 

while True: 
	yanzhengma = makeGode(5) 
	print("得到的这个验证码是:{}".format(yanzhengma)) time.sleep(0.3)

7.8 函数中的默认参数

定义函数的时候,给参数一个默认值,那么调用函数不传入参数默认就是默认值
传了参数以我传入的参数为准。

def add(n1=100,n2=200):      #赋予形参默认参数数值 如果调用时不传入参数 则会使用默认参数数值
	sum = n1 + n2 
	return sum 

num = add(5,7) 
print(num)

7.9 函数的关键字参数

如果没有指定关键字参数,那么默认就是位置参数。位置参数要求参数的顺序一一对应
需要注意的一点:关键字参数只能在位置参数的后面

def add(n1,n2): 
	sum = n1 - n2 
	return sum 

num = add(n2=5,n1=7) #关键字参数。 
print(num)

7.10 函数的可变参数

调用函数的时候参数的个数可以变化,那么就要求在定义函数的时候,形参的个数不能写死。
要用*args来定义。args可以用其他名字命名。按规范最好使用args命名。args的数据类型是元组
案例:

# 实现所有参数的求和 
def func(*args):    #可变参数   可以传入多个参数 按照情况 需要传入几个就可以传入几个
	print(type(args)) 
	sum = 0 
	for a in args: 
		sum += a 
		return sum 

jieguo = func(6,7,3,4) 
print(jieguo)

7.11 成员变量和局部变量

7.12 成员变量(全局变量)

定义在函数或者方法的外面的变量称之为成员变量,可以在当前脚本中所有的函数或者方法中被使用

例如:
money = 500 #成员变量
 #可以从函数里面去修改成员变量的值,需要去引入一个关键字global去申明成员变量 
 
 def getMoney(): 
 	print("获得了{}元".format(money)) 

def setMoney(): 
	m = money - 200 
	return m 

getMoney() 
qian = setMoney() 
print("钱变成了{}元".format(qian))

7.13 局部变量

定义在函数或者方法的里面的变量称之为局部变量,只能在当前函数或者方法中被使用.参数也是当前函数的 局部变量

def getMoney(): 
	money = 500
	print("获得了{}元".format(money)) 

def setMoney(): 
	m = money - 200 #money报错,无法使用  因为money是函数getMoney中定义的局部变量此函数无法调用
	return m 

getMoney() 
qian = setMoney() 
print("钱变成了{}元".format(qian))

7.14 申明成员变量(全局变量)

想在函数的里面去使用这个成员变量,并且修改这个成员变量。
需要去引入一个关键字 global 去申明成员变量

例如:
money = 500 # 成员变量 
def getMoney(): 
	global money       #只有申明了  函数内部对money进行的操作才会同步更新到全局变量
	money -= 100         #money会减少
	print("函数里面的money:",money) 

getMoney() 
print("成员变量的money",money)
声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。