编程语言
首页 > 编程语言> > Python_1（面向对象前）

Python_1（面向对象前）

作者：互联网

Python

创建文件书写代码

运行代码

image-20220904142128426

注释

'''
	不会执行
'''
"""
	不会执行
"""

Python代码中三种波浪线和PEP8

变量

#定义一个变量,存储你的名字
name = '张三'
#使用变量打印名字，不需要加引号
print(name)  #张三
#如果给name添加引号，添加引号之后,输出的就是引号中的内
print( 'name ' )  # name

在cmd终端中运行Python代码

python 代码文件的名字

变量名的命名规范

数据类型

类型转换

image-20220904170846037

输入

result = input('请输入内容: ')
print(type(result), result) #打印数据类型和数据值
#1．直接回车<class 'str'>
#2.小明<class 'str'小明
#3．18 <class "str '> 18
#4. True<class 'str'> True

输出

格式化输出

#要求按照以下个数输出个人信息
#我的名字是xx，年龄是xx，身高是xx m# 使用格式化输出实现
# print('我的名字是name，年龄是age，身高是height m')
print( '我的名字是 %s，年龄是%d，身高是%f m' %(name,age,height))
#小数默认显示6位，如果想要指定显示小数点后几位，%.nf , n需要换成具体的整数数字,即保留小数的位置
print('我的名字是 %s，年龄是%d，身高是%.2f m' % (name，age,height)) #两位小数
print('我的名字是%s，年龄是%d，身高是%.1f m' % (name，age,height)) #一位小数

# 补充
stu_num = 1 # 学号
#我的学号是000001
print('我的学号是%d’% stu_num)
# %0nd n需要换成具体的整数数字，表示整数一共占几位
print('我的学号是%06d' % stu_num)
      
num = 90 #考试的及格率
#某次考试的及格率为98%，如果在格式化中需要显示%，在书写的使用需要使用两个%%才可以
print('某次考试的及格率为%d%%' % num)|

快捷键（小操作）

运算符

算数运算符

image-20220904175214386

比较运算符

例题

书写程序，制作一个加法计算器。

用户依次输入2个整数，系统自动进行加法运算，并打印结果。

#书写代码
#获取用户输入的数字,类型是str
num1 = input('请输入第一个数字:')
num2 = input('请输入第二个数字:')
#求和，需要将str类型转换为数字类型
num = int( num1) + int( num2)
#打印求和的结果
print( num)

字符串格式化的补充

字符串.format()可以在任意版本中使用

1．在需要使用变量的地方使用 {} 占位
2.'{},{},...'.format(变量,变量,...)

name = '小明'
age = 18
height = 1.71
stu_num = 1
num = 90

print('我的名字是{},我的年龄是{},我的身高是{},我的学号是{},本次考试的及格率是{}%'.format(name, age, height, stu_num, num))
print('我的名字是{},我的年龄是{},我的身高是{:.3f},我的学号是{},本次考试的及格率是{}%'.format(name, age, height, stu_num, num))

运算符

逻辑运算符

逻辑运算符可以连接多个条件,在判断和循环中使用

and 逻辑与 和,并且 and连接两个条件,都必须为True，整体结果才为True，即一假为假(当第一个条件为False的时候,第二个条件就不再判断)
or 逻辑或 或者 or连接的两个条件，只要有一个条件为True ,整体结果就为True，即一真为真(当第一个条件为True的时候,第二个条件就不再判断)
not 逻辑非 取反 not后边的条件，如果本来是True,变为False，本来是False,变为True

image-20220904184721978

赋值运算符

赋值运算符=，作用就是将等号右边的值保存到等号左边的变量中
复合赋值运算符(将算术运算符和赋值运算符进行结合)

+= -= *= /= //= %=

a += b   ===>  a = a + b

判断

if的基本结构

if else 结构

如果条件成立做什么事否则(条件不成立)做另一件事

if elif else结构

Debug 调试代码

debug在代码中出现问题错误(bug)，可以使用debug来调试代码,查找错误.我们使用debug主要用来查看代码的执行步骤

  1. 打断点

    • 在pycharm中，代码和行号之间进行点击，出现小红点即打断点，再次点击小红点会取消断点
    • 断点的位置：一般来说会在代码的第一行(在程序运行的时候,想要在什么地方停下来)
    • 注意点：可能会出现的 bug(pycharm软件的问题)：代码中只有一个断点的时候不能debug调试查看代码执行过程，解决方案,在代码其他任意地方多加一个断点

    image-20220904200147168

  2. 右键debug运行代码

    image-20220904200233050

  3. 单步执行代码

    image-20220904200338092

if 嵌套

案例：猜拳游戏

剪刀  石头  布
剪刀  赢  布
石头  赢  剪刀
布    赢  石头

案例的步骤:
1.自己出拳(石头(1)/剪刀(2)/布(3)) input(player)
2.电脑随机出拳(使用随机数模块(工具)完成)(computer)
3.判断输赢
3.1 玩家胜利
3.1.1 player==1 and computer == 2
or
3.1.2 player==2 and computer == 3
or
3.1.3 player==3 and computer == 1
3.2平局  player == computer
3.3玩家输了else

随机出拳

案例中需要电脑随机出拳,即随机出1 2 3
在Python中想要随机获得整数数字可以使用如下方法
#1，导入随机数工具包
import random
#2.使用工具包中的工具产生指定范围内的数字
random.randint(a, b) #产生[a, b]之间的随机整数,包含a b 

import random #这行代码习惯性的放在第一行

num = random.randint(1,3)
print(num)

import random

comNum = random.randint(1, 3)
print('欢迎来到猜拳游戏，游戏规则：石头--1；剪刀--2；布--3')
playNum = int(input('您这次出：'))
print(f'您出的是{playNum},电脑出的是{comNum}')
if (playNum>=1) and playNum <=3:
    if (playNum == 1 and comNum ==2) or (playNum==2 and comNum ==3) or (playNum ==3 and comNum ==1):
        print('恭喜您获得胜利！')
    elif playNum == comNum:
        print('不分伯仲，打成平手！')
    else:
        print('很遗憾您输了')
else:
    print('请输入正确范围内的数字！')

循环

程序开发中(写代码)，有三大流程(三大结构)：

  1. 顺序，代码从上到下,全部执行
  2. 分支，判断语句,代码有选择性的执行
  3. 循环,重复执行某一部分的代码
    • 循环的作用就是让指定的代码重复的执行

死循环和无限循环

while True:
	重复执行的代码 #可以在if 的上边
    if判断条件:
		break #关键字的作用就是终止循环,当代码执行遇到break ,这个循环就不再执行了
	重复执行的代码#可以在if 的下边

import random

while True:
    comNum = random.randint(1, 3)
    playNum = int(input('欢迎来到猜拳游戏，游戏规则：石头--1；剪刀--2；布--3；退出--0；您这次出：'))
    if playNum == 0:
        print('退出成功！')
        break
    print(f'您出的是{playNum},电脑出的是{comNum}')
    if (playNum == 1 and comNum ==2) or (playNum==2 and comNum ==3) or (playNum ==3 and comNum ==1):
        print('恭喜您获得胜利！')
    elif playNum == comNum:
        print('不分伯仲，打成平手！')
    else:
        print('很遗憾您输了')

1-100 数字的和

# 1-100 数字的和
num = 0
i = 1
while i<=100:
    num = num +i
    i = i+1
print(num)

1-100 偶数的和

# 1-100 偶数的和
num = 0
i = 0
while i <=100:
    if i % 2==0:
        num = num + i
    i = i +1
print(num)

总结

  1. 字符串和数字之间不能比大小，但可以判断是否相等(一定不相等)
  2. 在判断中使用or的时候，后边的判断条件一定要写全,不能直写一个数据值
  3. 数字来说: False，其余的全是True，对于字符串来说，空字符串""，是False,其余的额全是True

for循环

for循环也可以让指定的代码重复执行(循环)
for循环可以遍历容器中的数据(
	遍历:从容器中把数据一个一个取出
	容器:可以简单理解为盒子，盒子中可以存放很多的数据（字符串str,列表list，元组 tuple，字典dict
    )
for循环 也可以称为 for遍历

for做指定次数的循环

for 变量 in range(n):
	重复执行的代码
    
#1. range() 是 Python 中的函数，作用使用可以生成 [0,n) 之间的整数，是不包含n的，一共有n个数字，所以这个循环执行n次
#2.想让for循环循环多少次,n就写几
#3.变量的值也是每次循环从[0，n)取出一个值，第一次取得是0 ,最后一次取的是n-1

range（）变形

#需求:使用for循环获取5到10之间的数字
for变量in range(a, b):
	重复的代码
    
#range(a, b)作用是生成〔a, b)之间的整数数字，不包含b

for i in range(5, 11):
    # 不包括11
    print(i)

break和continue

# 1，获取你输入的字符串
result = input('请输入一个字符串: ')
# 2。遍历打印这个字符串
for i in result:
    # 3，在遍历的时候,如果这个字符是e，不打印(即后续的代码不执行)
    if i == 'e':
        continue
# 本次循环后续的代码不执行,执行下一次循环
    print(i)
print('-' * 30)

for i in result:
    # 在遍历的时候,如果这个字符是e，不打印(即后续的代码不执行)
    # 如果这个字符不是e，打印
    if i != "e ":
        print(i)

容器

字符串

定义

下标

str1 = " abcdefg"
# 1，打印字符串中最开始位置的字符
print(str1[0])  # a
# 2，打印后一个位置的数据
print(str1[-1])  # g
# 3，打印倒数第二个位置的字特
print(str1[-2])  # f
# 打印下标为2的致据
print(str1[2])  # c
# 获取字符串中字符的个致(获取字符串的长度)
# len  字符串  #length(长度)
num = len(str1)
print(num)
# 长度-1的下标位查是最后一个字符
print(str1[num - 1])  # g最后一个字符,倒数第一个
print(str1[len(str1) - 1])  # g最后一个字符,倒数第一个

切片

字符串的查找方法：

str1 = "and itcast and itheima and Python"
# 在字符串里查找and
num = str1.find('and')
print(num)

# 在字符串中查找第二个and出现的下标，从第一次出现的后一位开始找
num1 = str1.find('and', num+1)
print(num1)  # 11

# 在字符串中查找第三个and出现的下标，从第二次出现的后一位开始找
num2 = str1.find('and', num1+1)
print(num2)  # 23

# 在字符串中查找第四个and出现的下标，从第三次出现的后一位开始找
num3 = str1.find('and', num2+1)
print(num3)  # -1

字符串的替换方法 replace

字符串.replace(old_str，new_str，count)

image-20220905195715372

字符串的拆分

image-20220905202846948

字符串的链接join

list1 = [ 'good' ,'good', 'study ' ]
#1．将列表中的字符串使用空格连起来
str1 = ' '.join(list1)
print(str1) # good good study
# 2．将列表中的字符串使用and 连起来
str2 = ' and '.join(list1)
print(str2)  # good and good and study

列表

定义

# 1．类实例化的方式(不常用)
# 1.1定义空列表(没有任何数据的列表)
#变量= list()
list1 = list()
print(type(list1), list1)   # <class 'list'>[]
# 1.2类型转换list(容器)  将其他的容器转换为列表
#转换字符串会将字符串中的每个字符作为一个数据存入到列表
list2 = list('hello')
print(type(list2), list2) # <class 'list'> [ 'h
, 'e ', 'l'，'l','o']
#2，直接使用[]进行定义(常用)

# 2.1定义空列表
my_list = []
print(my_list)  # []
#2.2定义非空列表
my_list1 = [1，'小明'，3.14，False]
print(my_list1)  # [1,，'小明'，3.14,False]

列表支持下标和切片

list1 =['小明',18,1.71,True]

#获取第一个数据,名字
print(list1[0])

#获取最后一个数据
print(list1[-1])

# 第一第二个数据
print(list1[0:2])  # ['小明'，18]

#列表页支持 len()求长度 , 求数据元素个数
print(len(list1))  #4

查找 - 查找列表中数据下标的方法

查找 - 判断是否存在

查找 - 统计出现的次数

my_list =[1，3，5，7，2，3]
#找数据3出现的下标
num = my_list.index(3)
print(num)  # 1

#找数据4出现的下标
#num1 = my_list.index(4) #代码会报错
if 4 in my_list:
	num1 = my_list.index(4)
    print(num1)
else:
	print('不存在数据4')
    
# my_list.count(4) 统计 数据4出现的次数
if my_list.count(4)> 0:
	num1 = my_list.index(4)
    print(num1)
else:
	print('不存在数据4')

添加数据的方法

补充：列表推导式

变量名 = [生成数据的规则 for 变量 in xxx]  # 循环每执行一次，在列表中添加一个数据

list1 = []
for i in range(5):
	list1.append(i)
    
range(start，end, step)
range(1，10)    #1 2 3 4 5 6 7 8 9
range(1，10，1) #1 2 3 4 5 6 7 8 9
range(1，10，2) # 1 3 5 7 9
range(1，10，3) # 1 4 7
range(1，10，5) # 1 6

image-20220905214321990

列表

定义

变量 = [数据,数据,...]

添加

列表.append

查询

列表.index(数据)
列表.count(数据)

修改操作

想要修改列中的指定下标位置的数据,使用的语法是:

列表[下标] =数据

#字符串中字符不能使用下标修改

#定义列表
my_list = [1，3, 5，7]

# 1．想要将下标为1的数据修改为22
my_list[1] = 22
print(my_list)# [1，22，5，7]

#修改最后一个位置的数据,改为'hello'
my_list[-1] = 'hello'
print(my_list)# [1，22，5，"hello" ]

# 2．如果指定的下标不存在，会报错的
# my_list[10] = 10 #代码会报错

删除操作

列表的反转（倒置）

字符串中反转倒置:字符串[::-1]

列表中 反转和倒置:
1.列表[::-1]  # 使用切片的方法,会得到一个新列表，原列表不会发生改变
2.列表.reverse   #直接修改原列表，返回None

列表的复制

将列表中的数据复制一份,给到一个新的列表
#使用场景:有一个列表，需要修改操作列表中的数据，修改之后，需要和原数据进行对比,即原数据不能改

1．使用切片
变量=列表[:]

2．使用copy方法
变量=列表.copy()

列表的排序

列表的排序，一般来说都是对数字进行排序的

列表.sort()  #按照升序排序，从小到大
列表.sort(reverse=True)

#降序排序，从大到小

my_list = [1，3，5，7，9，2，4，6，8，0]

#升序排序
my_list.sort()
print(my_list)

# 降序排序
my_list.sort(reverse=True)
print(my_list)

列表嵌套

列表嵌套，列表中的内容还是列表
使用下标来确定获取的是什么类型的数据,然后确定可以继续进行什么操作

元组

定义

常用方法

字典

  1. 字典 dict，字典中的数据是由键(key)值(value)对组成的(键表示数据的
    名字,值就是具体的数据)
  2. 在字典中一组键值对是一个数据，多个键值对之间使用逗号隔开
    变量= {key : value， key : value, ...}
  3. 一个字典中的键是唯一的,不能重复,值可以是任意数据
  4. 字典中的键一般都是字符串,可以是数字,不能是列表

定义

# 1．使用类实例化的方法
my_dict = dict()
print(type(my_dict), my_dict)  # <cLass 'dict ' > {
# dict()不能转列表和元组,字符串
# 2．直接使用{}定义
# 2.1空字典
my_dict1 = {}
print(type(my_dict1), my_dict1)  # <class 'dict'> {0}
# 2.2非空字典，小明( 'name ' ) 18( ' age' ) 1.71 ( ' height ' ) True(is_men)抽烟喝酒烫头('Like ')
my_dict2 = {"name": "小明", "age": 18, "height": 1.71, "is_men": True, "like": ["抽烟", "喝酒", "烫头"]}

print(my_dict2)
print(len(my_dict2))

增加和修改操作

my_dict = {"name":"小明", "age": 18, "like": ['抽烟', '喝酒', '烫头']}

my_dict['sex'] = '男'
print(my_dict)

my_dict["age"]=19
print(my_dict)

my_dict["like"].append('打游戏')
print(my_dict)

删除

del 字典 [键]

字典.pop(键)#键必须书写

查询 - 根据键获取对应的值

字典的遍历

对字典的键进行遍历

for 变量 in 字典:
	print(变量)  # 变量就是字典的key，键
    
for 变量 in 字典. keys():    # 字典.keys()可以获取字典中所有的键
	print(变量)

对字典的值进行遍历

for 变量 in 字典.values( ):   #字典.values()可以获取字典中所有的值
    print(变量)

对字典的键值对进行遍历

#变量1就是键，变量2就是键对应的值

for变量1，变量2 in字典.items( ):   #字典.items()获取键值对
	print(变量1，变量2)

my_dict = {"name":"小明", "age": 18, 'sex': '男'}

for k in my_dict.keys():
    print(k)

for v in my_dict.values():
    print(v)

for k,v in my_dict.items():
    print(k,v)

容器部分总结

# 1．字符串，列表，元组支持加法运算
str1 = 'hello' + ' world'   # 'hello world'
list1 = [1,2] +[3,4]  # [1,2,3,4]
tuple1 = (1,2)+ (3,4)  # (1,2,3,4)

#2．字符串列表元组支持乘一个数字
' hello ' * 3   #===> 'hello hello hello '
[1，2]* 3       #===>[1，2，1，2，1，2]
(1，2)* 3       #===>(1，2，1，2,1，2)

#3. len()在容器中都可以使用

#4. in 关键字在容器中都可以使用，注意，在字典中判断的是字典的键是否存在

函数

print()
input() ---> str
type()

概念

函数定义

  1. 将多行代码放在一块,起名字的过程，称为函数定义

  2. 函数必须先定义后调用

函数的调用

文档注释

文档注释的本质,还是注释，只不过书写的位置和作用比较特殊．

1．书写位置，在函数名的下方使用三对双引号进行的注释
2．作用:告诉别人这个函数如何使用的,干什么的
3．查看，在调用的时候，将光标放到函数名上,使用快捷键ctrl +q(windows)   Mac(ctrl j)

ctr1(cmd)B转到函数声明中查看(按住Ctrl(cmd）鼠标左键点击)

image-20220907112649184

函数的嵌套调用

def func1():
    print(1)
    print('func1')
    print(2)

def func2():
    print(3)
    func1()
    print(4)
    
print(5)
func2()
print(6)
#5 3 1 2 4 6

image-20220907113608824

练习

有如下列表:
my_list = [{ 'id ' : 1 , ' money' : 10}， { 'id': 2， 'money ': 20}， { 'id ':3,'money ' : 30}， { 'id': 4, 'money ' : 40}]

要求:定义一个函数func，功能如下
1．如果字典中ID的值为奇数,则对money的值加20
2．如果字典中ID的值为偶数，则对money的值加10
3．打印输出列表,查看最终的结果


my_list = [{'id': 1, 'money': 10}, {'id': 2, 'money': 20}, {'id': 3, 'money': 30}, {'id': 4, 'money': 40}]


def func():
    for i in my_list:
        if i.get('id') % 2 == 1:
            i['money'] = i.get('money') + 20
        else:
            i['money'] = i.get('money') + 10

    print(my_list)

func()

1．自定义以下程序，实现如下要求
2．能够获取测试人员输入的信息(登录/测试)
3．获取每组测试数据的用户名,密码和预期结果组成一下的数据格式进行打印[()，()，()]或者[[]，[]，[]]

比如:
输入登录组成的列表为
[ ( "admin"， "123456"，"登录成功")，( "root", "123456"，"登录失败")]
或者
[ [ "admin"，"123456"，"登录成功"]，["root", "123456"，"登录失败"]]

输入 注册 组成的列表为
[( "abcd", "123456")，( "xyz" , "123456")]

my_dict = {'登录': [
    {'desc': '正确的用户名密码', 'username': ' admin', 'password ': '123456', 'expect': '登录成功'},
    {'desc': '错误的用户名', 'username': 'root ', 'password': '123456', 'expect': '登录失败'},
    {'desc ': '错误的密码', 'username': 'admin', 'password': '123123', 'expect': '登录失败'},
    {'desc': '错误的用户名和密码', 'username': 'aaaa', 'password': '123123', 'expect': '登录失败'}],
    '注册': [{'desc ': '注册1', 'username': 'abcd', 'password': '123456'},
             {'desc ': '注册1 ', 'username': 'xyz ', 'password': '123456'}]}

key = input('请输入登录或注册：')
info_list=[]
if key == '登录':
    print('登录组成的列表为：')
    for d in my_dict.get('登录'):
        log_tuple = (d.get('username'),d.get('password'),d.get('expect'))
        info_list.append(log_tuple)
    print(info_list)
elif key == '注册':
    print('注册组成的列表为：')
    for f in my_dict.get('注册'):
        new_tuple = (f.get('username'),f.get('password'))
        info_list.append(new_tuple)
    print(info_list)

else:
    print('输入错误！')

补充 - 列表去重

my_list = [1,2,3,1,2,3,1,2,4]
new_list = []

for i in my_list:
    if i not in new_list:
        new_list.append(i)

print(new_list)

函数基础

函数参数

# 1.定义一个函数，my_sum ,对两个数字进行求和计算．

def my_sum( ) :
    num1 = 10
    num2 = 20
    num = num1 + num2
    print(num)
    
my_sum( )

# 函数存在的问题，这个函数只能对10 和20进行求和，不能对任意的函数进行求和计算．
# 问题的解决:想要解决这个问题,可以使用函数参数来解决

函数参数:在函数定义的时候,使用变量代替具体的数据值(进行占位)，在函数调用的时候，传递具体的数据值．
好处:让函数更加通用,能够解决以类问题，而不是单纯的一个

掌握理解形参和实参的概念

#1．定义一个函数，my_sum ,对两个数字进行求和计算.
# num1和 num2是函数定义时候的参数，起到占位的作用，没有具体的数据值，称为形式参数，简称形参


def my_sum(num1,num2):
num = num1 + num2    #在什么时候定义参数,函数中使用的数据会会变化的时候,就可以定义为参数
print(num)


my_sum(10，20)#在函数调用的时候，括号中的数据会传递给形参，是具体的数据值，称为实际参数，简称实参
my_sum(1，2)
#目前书写的函数，在定义的时候如果有形参，那么在调用的时候，必须传递实参值，个数要对应,否则会报错

函数的返回值

def my_sum(a, b):
	num = a + b
# print(num)#代码中没有返回值,只有 print,这个结果只能在函数中用一次,不能后续使用
# 我们想要将这个求和的结果在后续的代码中使用，需要使用return 将求和的结果进行返回
	return num # 将这个结果返回到调用的地方法
	# return之后的代码会执行吗
	print('我是return之后的代码，我会执行吗--->不会执行')
    
    
#1．函数中没有 print，只有return，想要查看结果,需要在调用的时候使用 print
print(my_sum(1，2))

# 2，想要将函数中返回的结果,在后续代码中使用，即需要将这个数据保存下来，需要使用变量来接收(保存)函数的返回值(执行结果)
#变量=函数()
result = my_sum(10，20)# 将求和的结果保存到变量result中，可以在后续代码中使用

print('使用:1，直接打印:',result)
print('使用:2，对数字加10: ' , result + 10)

变量进阶[底层]

Python底层是如何处理数据？

变量的引用

  1. 在定义变量的时候变量=数据值，Python 解释器会在内存中开辟两块空间

  2. 变量和数据都有自己的空间

  3. 日常简单理解，将数据保存到变量的内存中，本质是将数据的地址保存到变量对应的内存中

  4. 变量中存储数据地址的行为 就是引用（变量引用了数据的地址，简单说就是变量中存储数据)，存储的地址称为引用地址

  5. 可以使用 id() 来获取变量中的引用地址(即数据的地址)，如果两个变量的id(）获取的引用地址一样，即代表着，两个变量引用了同一个数据，是同一个数据

  6. 只有 赋值运算符=，可以改变变量的引用(等号左边数据的引用)

  7. python中数据的传递,都是传递的引用

image-20220907172429663

可变类型和不可变类型

my_list = [1, 2, 3]
my_list1 = [1, 2, 3]
print('my_list :', id(my_list), id(my_list[1]))
print('my_list1:', id(my_list1))
my_list[1] = 10
print(my_list)

print('my_list : ', id(my_list), id(my_list[1]))
my_tuple = (1, 2, [3, 4])  # 元组中存储的是1的地址，2的地址，和列表的地址#元组中的数据不能改变,是值这个三个地址不能改变
print(my_tuple,id(my_tuple[-1]))
my_tuple[-1][0] = 10  # 修改的是列表中下标为0的位置的引用地址，列表的地址没变，元组中的内容没有变化
print(my_tuple, id(my_tuple[-1]))

练习

image-20220907174034231

面试题 - 列表的 += 操作

def func(list1):
	list1 += [1,2]
    
    
my_list = ['a','b']
func(my_list)
print(my_list) ===> ?

1、['a','b']   2、['a','b',1，2]

image-20220907174647838

组包和拆包

a = 10
b = 20
# 组包
c = b, a  # 组包
print(type(c), c)  # <class 'tuple'>(10,20)

# 拆包
a, b = c
print(a, b)

x, y, z = [1, 2, 3]
print(x, y, z)    # 1 2 3

局部变量和全局变量

局部变量

def func1():
num = 10 # num就是局部变量
print(f"func1函数中{num}")

def func2():
num = 100 #可以在不同函数中定义名字相同的局部变量,没有影
print(f"func2函数中{num}")

func1()# 10
func2()# 100
func1()# 10

全局变量

g_num =10 #全局变量
def func1():
	print(f 'func1中 {g_num} ') #在函数中可以读取全局变量的值
def func2():
	g_num = 20 #定义局部变量,不会影响全局变量
	print(f'func2中 {g_num}')
def func3(): 
	global g_num #这个函数中使用的 g_num都是全局变量，写在函数的第一行
    g_num = 30  # 修改了全局变量
	print(f'func3中 {g_num} ' )
    
# func1()# 10
# func2()# 20
# func1()#10
# func3()#30
# func1()#30
print(g_num)

函数进阶

返回值-函数返回多个数据值

def cacul(a,b):
    num1 = a+b
    num2 = a-b
    return num1,num2


result = cacul(3,4)
print(result,result[0],result[1])

#写法二：直接拆包
x,y = cacul(5,6)
print(x,y)

函数参数

函数传参的方式

def func(a, b，c):
print(f'a: {a}, b: {b}，c: {c}')

#位置传参
func(1，2，3)

#关键字传参
func(a=2，b=3，c=1)

#混合使用
func(1，3,c=5)

缺省参数

  1. 定义方式
    • 在函数定义的时候，给形参一个默认的数据值，这个形参就变为缺省参数，
    • 注意，缺省参数的书写要放在普通参数的后边
  2. 特点(好处)
    • 缺省参数，在函数调用的时候，可以传递实参值，也可以不传递实参值
    • 如果传参,使用的就是传递的实参值，如果不传参,使用的就是默认值
def show_info(name,sex="保密"):
	print(name，sex)
    
    
show_info('小王')
show_info('小王','男')

多值参数 [ 可变参数 / 不定长参数 ]

print(1)
print(1,2)
print(1,2,3)
print(1,2,3,4)

当我们在书写函数的时候，不确定参数的具体个数时，可以使用不定长参数

练习

不定长参数补充

def my_sum(*args, **kwargs):
    num = 0
    for i in args:
        num += i

    for j in kwargs.values():
        num += j

    print(num)


# 需求，my_list = [1，2，3，4] 字典my_dict = {'a': 1, 'b': 2, 'c': 3, 'd':4}
my_list = [1, 2, 3, 4]
my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# 将字典和列表中的数据使用my_sum函数进行求和，该如何传参的问题
# my_sum(1,2,3,4)
# my_sum(a=1，b=2，c=3,d=4)

# 想要将列表(元组)中的数据分别作为位置参数,进行传参,需要对列表进行拆包操作
my_sum(*my_list)  # my _sum(1，2，3，4)
# 想要将字典中的数据，作为关键字传参,，需要使用使用**对字典进行拆包
my_sum(**my_dict)  # my_sum(a=1，b=2,c=3，d=4)

匿名函数

练习

1．定义一个匿名函数可以求两个数的乘积

2．定义一个匿名函数，参数为字典,返回字典中键为age的值

# 1．定义一个匿名函数可以求两个数的乘积（参数需要两个，)
func1 = lambda a, b: a * b

# 2．定义一个匿名函数，参数为字典,返回字典中键为age的值
# 参数只是一个占位的作用,定义的时候没有具体的数据值，形参的值是在调用的时候进行传递,此时,形参才有数据值
# 形参的类型就是由实参来决定的，在函数定义的时候,参数只是一个符号,写什么都可以，想让其是字典类型,只需要保证实参是字典即可
func2 = lambda x: x.get('age')
func3 = lambda x: x['age']

print(func1(1, 2))
print(func1(3, 2))

my_dict = {'name': "张三", 'age': 18}
print(func2(my_dict))
print(func3(my_dict))

image-20220909091756974

标签：函数,Python,代码,list,列表,面向对象,print,my
来源： https://www.cnblogs.com/lzy5967/p/16671581.html