0基础快速入门Python，小白必看
2024-05-12 09:48:25
- 1. python的基本语法
- 1.1 变量
- 1.12 如何定义变量
- 1.13 输出一个变量
- 1.14 变量的数据类型
- 1.15 变量的运算
- 1.16 变量的输入
- 1.17 变量的类型转换
- 1.18 变量的格式化输出
- 1.1 变量
- 2. 逻辑判断（分支结构）
- 2.1 单个分支结构
- 2.2 多个分支结构
- 2.3 逻辑运算符
- 2.31 and 用法
- 2.32 or 用法
- 2.33 not 用法
- 2.4 逻辑嵌套
- 3. 循环
- 3.1 循环的定义
- 3.2 while 循环的语法
- 3.21 while 循环实现累加
- 3.22 while 里面的 break 用法
- 3.23 while 里面的 continue 用法
- 3.3 循环嵌套
- 4. 容器
- 4.1 字符串
- 4.11 字符串的概念
- 4.12 字符串通过下标访问对应的元素
- 4.13 字符串的遍历
- 4.14 字符串的常用API
- 4.141 字符串的替换
- 4.142 字符串的查找
- 4.143 字符串的切片
- 扩展 判断字符串是否是数字
- 扩展 判断字符串是否为字母
- 4.2 列表
- 4.21 列表和数组的区别
- 4.22 列表添加元素
- 4.23 列表删除元素
- 4.24 列表查找元素的下标
- 4.25 列表修改元素
- 4.26 列表的排序
- 5. 元组
- 5.11 元组的定义
- 5.12 元组的应用
- 5.13 元组不支持 增，删，改
- 5.14 元组的遍历
- 5.15 元组的查询
- 6. 字典
- 6.1 字典的概念
- 6.2 字典的定义
- 6.3 字典添加元素
- 6.4 字典的元素修改
- 6.5 字典的查询
- 6.6 字典的遍历
- 6.61 取所有的键和值
- 6.62 取所有的键
- 6.63 取所有的值
- 6.64 嵌套字典
- 7. 函数
- 7.1 函数的概念
- 7.2 函数的作用
- 7.4 函数的定义
- 7.5 函数的调用
- 7.6 函数的参数
- 7.61 单个参数
- 7.62 多个参数
- 7.63 参数的总结
- 7.7 函数的返回值 return
- 7.71 单个返回值
- 7.72 多个返回值
- 扩展 函数与返回值的应用场景
- 7.8 函数中的默认参数
- 7.9 函数的关键字参数
- 7.10 函数的可变参数
- 7.11 成员变量和局部变量
- 7.12 成员变量（全局变量）
- 7.13 局部变量
- 7.14 申明成员变量（全局变量）
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 变量的运算
s1 = "12"
s2 = "3"
s = s1 + s2
print("结果是：",s)
#结果是：123
s = "好好学习\t"
n = 10
jieguo = s * n
print("结果是："jieguo)
#结果是：好好学习 好好学习 好好学习 好好学习 好好学习 好好学习 好好学习 好好学习 好好学习 好好学习
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格式化输出
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 单个分支结构
例如：如果分数超过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 逻辑嵌套
例如：
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 = 1while j <= i:print("{}x{}={}".format(j,i,i*j), end=" \t")j +=1print()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 字符串通过下标访问对应的元素
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 = 500print("获得了{}元".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)
0基础快速入门Python，小白必看相关推荐
- 新手如何快速入门Python(菜鸟必看篇)
学习任何一门语言都是从入门(1年左右),通过不间断练习达到熟练水准(3到5年),少数人最终能精通语言,成为执牛耳者,他们是金字塔的最顶层.虽然万事开头难,但好的开始是成功的一半,今天这篇文章就来谈谈如 ...
- Kubernetes零基础快速入门！初学者必看！
起源 Kubernetes 源自于 google 内部的服务编排系统 - borg,诞生于2014年.它汲取了google 十五年生产环境的经验积累,并融合了社区优秀的idea和实践经验. 名字 Ku ...
- 0基础快速入门CSS技术栈（4）—图解详细阐述CSS的复合选择器、标签显示模式、行高、CSS背景，及最为重要的CSS三大特性附带权重计算笔试题（附详细案例源码解析过程）
文章目录 1. 0基础快速入门CSS技术栈(4) 2. 重点提炼 3. CSS复合选择器 3.1 后代选择器(重点) 3.1.1 example01 3.2 子元素选择器 3.2.1 exmaple0 ...
- 计算机基础cpu知识,CPU基础知识: DIY装机小白必看的CPU知识扫盲
CPU也就是中央处理器,全拼为Central Processing Unit,在计算机中可以比喻成人的大脑.它是一块超大规模的集成电路,是一台计算机的运算核心和控制核心.它的功能主要是解释计算机指令以 ...
- 0基础如何入门Python编程
Python目前已经成为最受欢迎的编程语言之一,吸引了一大批粉丝,但是很多人在要跨入的时候犹豫了,原因竟然是觉得零基础学习Python太难了,真的是这样吗?零基础入门Python编程学习有什么好的技巧 ...
- 【0基础快速入门】Python学习快速参考手册
Python学习快速参考手册 目录 文章目录 Python学习快速参考手册 目录 @[toc] 下载 Python下载与配置 IDE下载与配置 第一章 · Python的基本语法 变量 数据类型 注释 ...
- Python网络爬虫入门篇---小白必看
1. 预备知识 学习者需要预先掌握Python的数字类型.字符串类型.分支.循环.函数.列表类型.字典类型.文件和第三方库使用等概念和编程方法. 2. Python爬虫基本流程 a. 发送请求 使用 ...
- 万字【Python基础】保姆式教学，零基础快速入门Python
前言 又是爆肝干文的日子,继上次说要出一期Python新手入门教程系列文章后,就在不停地整理和码字,终于是把[基础入门]这一块给写出来了. 高级编程的[正则表达式]和[面向对象编程]内容我在之前已经出 ...
- 零基础快速入门python教程，结合新手练习的5大项目
Python是一门动态语言 与Java,C等相对,Python不用编译,像脚本一样直接运行.这就导致了,所有错误都是运行时的!即使有语法错误,或者异常,如果程序逻辑没有执行到,就不会有错误.比如一个i ...
最新文章
- 如何组织成功的bug bash--摘录
- php中一个经典的!==的用法
- 【项目管理】敏捷小品：Rupert 工业公司 项目：~Alpha~
- python中调用多进程加速处理文件
- SAP Spartacus autofocus directive，如何锁住使用了directive的元素本身？
- linux终端安装cuda,Ubuntu下安装CUDA10.0以及问题
- python xml.etree.ElementTree
- TensorFlow入门：计算图和梯度流
- Forever 0.5 (计算几何思维)
- 【20保研】厦门大学软件学院暑期夏令营招生简章
- three.js加载Obj三维模型
- 梯度消失、梯度爆炸产生的原因
- git Untracked files
- 使用分布式词汇对比词向量区分正反义词
- 用 NetworkX + Gephi + Nebula Graph 分析＜权力的游戏＞人物关系（上篇）
- 英文歌曲：Right Here Waiting(此情可待)
- 剑指offer系列-代码的鲁棒性
- 【网络仿真】ns-3基础（上）
- 计算机鼠标不动了,电脑上鼠标不动了怎么解决 鼠标不动了怎么办解决方案
- StandardServer.await: Invalid command 'GET /setting/webSocket HTTP/1.1' rece