ICode9

精准搜索请尝试: 精确搜索
首页 > 编程语言> 文章详细

Python_1(面向对象前)

2022-09-09 09:33:12  阅读:274  来源: 互联网

标签:函数 Python 代码 list 列表 面向对象 print my


Python

创建文件书写代码

  • 文件名不写中文
  • 后缀:.py
  • 代码要顶格书写
  • 标点符号为英文

运行代码

image-20220904142128426

注释

  • # :单行注释(井号+空格)

  • 三对单引号/双引号包裹起来的内容也是注释,可以换行,不会执行

    • 一般写在文件的最开始部分,或者文档注释处(函数)
'''
	不会执行
'''
"""
	不会执行
"""
  • 快捷键:ctrl + /

    1.可以选中多行,使用快捷键
    2.如果代码已经添加注释,再次使用快捷键,会取消注释

Python代码中三种波浪线和PEP8

  • 红色

    • 红色波浪线是代码的错误,必须处理,代码才能执行
    • 注意:某些代码没有写完,也会出现红色波浪线
  • 灰色

    • 灰色波浪线,不会影响代码的正常执行。基本上所有的灰色波浪线都是PEP8造成的
    • PEP8:是Python代码的书写规范,如果不按照这个规范书写,会给灰色波浪线提示,建议代码的书写按照PEP8的规范书写
    1.可以书写代码的时候注意PEP8的代码规范
    2.可以在书写完成之后,使用快捷键Ctrl Alt L来按照PEP8的规范自动格式化代码
    
  • 绿色

    • 不影响代码的正常执行,在引号中,认为你书写的内容不是一个单词,就会给你绿色提示。

变量

  • 作用:是用来存储数据的(在程序代码中出现的数据,想要保存下来使用,就必须使用变量),如:测试数据,用户名,密码,验证码

  • 变量注意事项

    • 变量必须先定义(保存数据)后使用(取出数据).
  • 定义变量
    变量名 = 数据值 #可以理解为是将数据值保存到变量中#

    • 比如:
      name =‘张三’ #定义一个变量name,存储的数据值是张三
  • 使用变量
    变量定义之后,想要是使用变量中的数据,直接使用变量名即可

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

在cmd终端中运行Python代码

python 代码文件的名字 

变量名的命名规范

  • 起名字的规范,标识符的规则

    1. 必须出字母数字和下划线组成,并且不能以数字开头

    2. 不能使用Python 中的关键字作为变量名

      • 关键字:Python自带的已经使用的标识符,具有特殊的作用
    3. 区分大小写

    4. 建议性的命名

      • 驼峰命名法

        • 大驼峰:每个单词的首字母大写MyName
        • 小驼峰:第一个单词的首字母小写,其余单词的首字母大写myName
      • 下划线连接法:每个单词之间使用下划线连接my_name

        Python 中的变量的定义使用的是下划线连接
        
      • 见名知意

        name 姓名 age 年龄 height 身高 ....
        

数据类型

  • 将生活常见的数据划分为不同的类型,因为不同的类型可以进行的操作是不一样的,数字需要加减乘除,文字不需要...

  • 数字类型

    • 整型( int),就是整数,即不带小数点的数。

    • 浮点型(float ),就是小数

    • 布尔类型(bool),只有两个值

      • True ,1

      • False,非0即真

        True和 False 都是 Python 中的关键字,注意大小写,不要写错了。
        
      • 复数类型3 +4i,不会用的

  • 非数字类型

    • 字符串: (str)使用引号引起来的就是字符串
    • 列表(list)[1,2,3,4]
    • 元组(tuple)(1,2,4,4)
    • 字典(dict) { 'name ' : '小明', 'age ' : 18}
  • type( )函数

    • 可以获取变量的数据类型

      • type(变量)
      想要将这个变量的类型在控制台显示,需要使用print输出print(type(变量))
      
  • 输出:

    print(type(age))
    #type(age) .print回车
    

类型转换

  • 根据代码的需要,将一种数据类型转换另一种数据类型(将input输入得到的数字转换为整型)

  • 语法:

    变量=要转换为的类型(原数据)
    
    1.数据原来是什么类型
    2.你要转换为什么类型
    
  • 注意点:数据类型转换,不会改变原来的数据的类型,会生成一个新的数据类型

image-20220904170846037

  • int() 将其他类型转换为int类型

    1.可以将float类型的数字转换为整型

    2.可以将整数类型的字符串3123

  • float() 将其他类型转换为浮点型

    1. 可以将int类型转换为浮点型float(3) ---> 3.0
    2. 可以将数字类型的字符串(整数类型和小数类型)转换为浮点型
  • str() 将其他类型转换为字符串类型

    任何类型都可以使用str()将其转换为字符串,一般都是直接加上引号
    

输入

  • 获取用户使用键盘录入的内容

  • 使用的函数是 input()

    变量= input('提示的信息')
    

    1.代码从上到下执行,遇到input函数之后,会暂停执行,等待用户的输入,如果不输入会一直等待

    2.在输入的过程中,遇到回车,代表本次输入结束

    3.会将你输入的内容保存到等号左边的变量中,并且变量的数据类型一定是str

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

输出

  • 输出使用的函数是print()函数,

  • 作用:将程序中的数据或者结果打印到控制台(屏幕)

    print( ' hello world ' )name = ‘小明·
    print( name)age = 18
    print( name,age) #可以使用逗号输出多个内容
    

格式化输出

  • 在字符串中指定的位置,输出变量中存储的值.

    1. 在需要使用变量的地方,使用特殊符号占位
    2. 使用变量填充占位的数据
  • %格式化输出占位符号

    • %d占粒,填充整型数据digit
    • %f 占位.填充浮点型数据float
    • %s 占位,填充字符串数据string
    补充:其实%s 的占位符,可以填充任意类型的数据
    
#要求按照以下个数输出个人信息
#我的名字是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)|
  • F-string( f字符串的格式化方法 )

    • f-string格式化的方法,想要使用,Python的版本>= 3.6
      1.需要在字符串的前边加上f""或者F""
      2.占位符号统一变为{}
      3.需要填充的变量 写在{}
    name = 'lzy'
    age = 21
    height = 172.15
    weight = 62
    
    print(f'我的名字叫{name},我的年龄是{age},我的身高是{height},我的体重是{weight}kg')
    
    print(f'我的名字叫{name},我的年龄是{age},我的身高是{height:.3f},我的体重是{weight:03d}kg')
    
    # 在字符串中想要输出换行:\n (转义字符)
    print(f'我的名字是{name},年龄是{age},身高是{height:.3f},\n我的体重是{weight:03d}kg')
    

快捷键(小操作)

  • 添加引号括号:可以直接选中要添加引号或者括号的内容,书写即可
  • 撤销:Ctrl z
  • 删除一行:Ctrl x
  • 复制粘贴一行:Ctrl d
  • 快速在代码下方,新建一行:shift回车

运算符

算数运算符

image-20220904175214386

  • 优先级:先算谁,再算谁(不确定优先级,就使用())

    () > ** 〉* / // % > + -
    

    image-20220904175417074

比较运算符

  • 比较运算符得到都是bool类型

    >  <  >=  <=
    
    • == 判断两个数是否相等,相等为True,不相等为False

    • != 判断两个数是否不相等,不相等为True,相等为False

例题

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

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

#书写代码
#获取用户输入的数字,类型是str
num1 = input('请输入第一个数字:')
num2 = input('请输入第二个数字:')
#求和,需要将str类型转换为数字类型
num = int( num1) + int( num2)
#打印求和的结果
print( num)
  • 易错点:input储存的都是str字符串,如果要进行算术运算,需要将string类型强转为int类型后,再进行运算。

字符串格式化的补充

字符串.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(如果) elif(如果) else(否则)三个关键字来实现
  • 在代码中有判断语句,待会不会全部执行,会有一部分不会执行

if的基本结构

  • 基本语法

    if 判断条件;
    	书写条件成立(真),执行的代码
        书写条件成立(真),执行的代码
        
    顶格书写,没有缩进的代码,和 if 无关,不管条件是否成立,都会执行
    
    # 1.if是一个关键字,和后续的判断条件之间需要一个空格
    # 2.判断条件后边需要一个冒号,不要少了
    # 3.冒号之后,回车,代码需要缩进,在pycharm中会自动进行缩进,一般是4个空格或者一个tab键
    #4、所有在if 代码下方的缩进中书写的代码,属于if语句的代码块,判断条件为True的时候会执行
    # 5.if代码块中的代码,要么都执行,要么都不执行
    # 6.if 代码块结束之后,代码要顶格书写(不再有缩进),表示是和if无关的代码
    
  • 代码案例

    1.使用input获取用户的年龄
    2.判断年龄是否满足18岁
    3.如果年龄大于等于(满足)18岁,输出'满18岁了,可以进入网吧为所欲为了'
    
    #1.使用input获取用户的年龄,类型是strage = input('请输入你的年龄: ")
    # 2.判断年龄是否满足18岁
    if int(age)>= 18:#字符串和 int类型不能比大小,先类型转换,再比大小
    #3,如果年龄大于等于(满足)18岁,输出"满18岁了,可以进入网吧为所欲为了'
    	print('满18 岁了,可以进入网吧为所欲为了')
        
    print('我和if判断没有关系,不管怎样,都会执行')
    
  • 练习

    1.获取用户输入的用户名信息
    2.如果用户名信息是admin,就在控制台输出出来
    
    name = input('请输入用户名:')
    if name=='admin':
        print('欢迎用户{}'.format(name))
    

if else 结构

如果条件成立做什么事否则(条件不成立)做另一件事
  • 基本语法

    if判断条件:
    	书写条件成立(真),执行的代码
    	书写条件成立(真),执行的代码
    else:
    	书写条件不成立(假),执行的代码
        书写条件不成立(假),执行的代码
        
    #1. else是关键字,后边需要冒号
    #2.冒号之后回车,同样需要缩进
    #3.处于else 代码下方缩进中的内容,属于else的代码块
    #4、if和else的代码块,只会执行其中的一个
    #5. else需要结合if使用
    #6.if else 之间不能有其他顶格书写的内容(不提elif)
    
  • 代码案例

    1,使用input获取用户的年龄
    2.判断年龄是否满足18岁
    3,如果年龄大于等于(满足)18 岁,输出‘满18 岁了,可以进入网吧为所欲为了'
    4、如果不满足,输出'不满18岁,回去写作业吧'
    
    age = input('请输入你的年龄:')
    
    if int(age) >= 18:
    	print('满18岁了,可以进入网吧为所欲为了")
    else:
    	print("不满18岁,回去写作业吧")
    
  • 练习

    1.获取用户输入的用户名
    2.判断用户名是admin 时,在控制台输出:欢迎admin登录!
    3.用户名是test 时,,在控制台输出:欢迎test登录!
    4、如果是其他信息,在控制台输出:查无此人!
    
    name = input('请输入用户名:')
    if name =='admin' or name =='test':
        print('欢迎用户{}'.format(name))
    else:
        print('查无此人!')
    
    name = input('请输入用户名:')
    if name =='admin':
        print('欢迎用户 admin ')
    elif name == 'test':
        print('欢迎用户 test')
    else:
        print('查无此人!')
    
  • 错误写法:

    #username =n ' admin'或者 'test'(一直True,空字符串是False)
    if username == 'admin' or 'test'
    	pass   #pass关键字,占位,
    

if elif else结构

  • 如果某个判断条件有多个,此时建议使用if elif else结构来实现

  • 语法

    if 判断条件1:
    	判断条件1成立,执行的代码
    elif 判断条件2:  #只有判断条件1不成立,才会判断判断条件2
    	判断条件2成立执行的代码
    else:
    	以上条件都不成立,执行的代码
        
    # 1. elif 也是关键字,后边和判断条件之间需要一个空格,判断条件之后需要冒号
    # 2.冒号之后回车需要缩进,处在这个缩进中的的代码表示是elif 的代码块
    #3,在一个if判断中,可以有很多个elif
    #4.只有if 的条件不成立,才会去判断elif的条件
    #5.在一个if中,如果有多个elif ,只要有一个条件成立,后续的所有都不再判断
    # 6. if elif else结构,和if的缩进相同的只能是elif和else,如果是其他的,就表示这个判断结构结束了
    
    if判断条件1:
    	执行的代码
    if判断条件2:
    	执行的代码
    if判断条件3:
    	执行的代码
        
    #多个if 的结构,每个if都会进行判断,之间没有关联系
    
  • 案例

    1.定义score变量记录考试分数
    2.如果分数是大于等于98分应该显示优
    3,如果分数是大于等于88分并且小于98分应该显示良
    4.如果分数是大于等于78分并且小于8B分应该显示中
    5.如果分数是大于等于68分并且小于78分应该显示差
    6.其它分数显示不及格
    
    score = int(input('请输入考试分数:'))
    if score >= 98:
        print('优秀')
    elif (score>=88) and score<98:
        print('良好')
    elif score>=78:
        print('中等')
    elif score>=68:
        print('差')
    else:
        print('不及格')
    

Debug 调试代码

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

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

    image-20220904200147168

  2. 右键debug运行代码

    image-20220904200233050

  3. 单步执行代码

    image-20220904200338092

if 嵌套

  • if 嵌套,是指在一个 if(elif else)中嵌套另一个if.

  • 使用场景:判断条件存在递进关系

    • 只有第一个条件满足了,才会判断第二个条件
  • 语法

    if 判断条件1:
    	判断条件1成立,执行的代码
        if 判断条件2:
    		判断条件2成立,执行的代码
        else:
    		判断条件2不成立,执行的代码
    else:
    	判断条件1不成立,执行的代码
    
  • 代码案例

    取款机取钱的过程,假定你的密码是:123456,账户余额为1000
    
    1.提示用户输入密码
    2.判断密码是否正确
    3.密码正确后,提示输入取款的金额
    4.判断取款的金额和余额的关系
    
    password = input('请输入密码:')
    if int(password) == 123456:
        money = int(input('请输入取款金额:'))
        if money <= 1000:
            print('取款成功!')
        else:
            print('您的余额不足,取款失败!')
    else:
        print('您的密码错误,请重新输入!')
    
    • 或者也可以预先设置密码和余额,再直接判断
    pwd = 123456
    money = 1000
    
  • 练习

    #假定某网站用户名固定为‘admin ',密码固定为"123456',验证码固定为‘8888"
    #1.获取用户输入的用户名,密码和验证码
    #2,先判断验证码是否正确,如果正确打印输出验证码正确,再判断用户名和密码是否正确
    #3.如果验证码不正确,直接输出验证码不正确,请重新输入
    
    psw = '123456'
    user = 'admin'
    ver = '8888'
    
    username = input('请输入用户名:')
    password = input('请输入密码:')
    verify = input('请输入验证码:')
    
    if verify == ver:
        print('验证码正确!')
        if username == user and password == psw:
            print('登录成功!')
        else:
            print('密码错误,请重新输入')
    else:
        print('验证码不正确,请重新输入')
    

案例:猜拳游戏

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

案例的步骤:
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. 循环,重复执行某一部分的代码
    • 循环的作用就是让指定的代码重复的执行
  • 语法

    1.设置循环的初始条件(计数器)
    2.书写循环的判断条件
    
    while 判断条件:
    	#3.需要重复执行的代码
    	#4.改变循环的初始条件(计数器)
        
    # while 是关键字
    
    # 设置循环的初始条件
    i = 0
    # 判断条件
    while i < 5:
        # 重复执行的代码
        print("尊上威武!")
        # 改变初始条件
        i = i+1
    

死循环和无限循环

  • 死循环:一般是由写代码的人不小心造成的bug,代码一直不停的运行下去

  • 无限循环:写代码的人故意让代码无限制的去执行,代码一直不停的运行下去

  • 无限循环的使用场景:在书写循环的时候,不确定循环要执行多少次

  • 无限循环的使用一般会在循环中添加一个 if判断,当if条件成立,使用关键字break来终止循环

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 变量名 in 容器:
    	重复执行的代码
    
    # 1. for和in都是关键字
    # 2.容器中有多少个数据,循环会执行多少次(0个数据,执行0次,...)
    # 3,每次循环,会将容器中数据取出一个保存到in 关键字前边的变量中
    

    image-20220905160434585

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

  • break 和 continue是Python中的两个关键字,只能在循环中使用
  • break:终止循环,即代码执行遇到break,循环不再执行,立即结束
  • continue:跳过本次循环。即代码执行遇到break,本次循环剩下的代码不再执行继续下一次循环
# 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)

容器

  • 容器:也可以称为是数据序列,或者高级数据类型,也是Python中的数据类型
  • 容器中可以存放多个数据

字符串

  • 字符串是容器,因为字符串中可以包含多个字符

定义

  • 定义:使用引号(单引号,双引号,三引号)引起来的内容就是字符串

    #4、字符串本身包含引号  I'm小明
    #4.1字符串本身包含单引号,则在定义的时候不能使用单引号#4.2字符串本身包含双引号,则在定义的时候不能使用双引号
    
    #5.字符串本身包含单引号,在定义的时候,我就是想使用单引号
    #5.1使用\转义字符,将字符串本身的引号进行转义\'--> '\” -->
    
    #5.3字字符串前边加上r""原生字符串,字符串中的\不会作为转义字符,文件操作会用一下
    my_str8 = r'I\'m小明'
    print(my_str8)
    my _str9 = r'I\\\'m 小明'
    print(my_str9)
    

下标

  • 下标(素引):就是指字符在字符串中的位置编号,这个编号就是下标
  • 这个编号一般来说都是从左到右进行编号的,从0开始的(Python中支持负数下标,从右到左进行编号的,从-1开始)
  • 下标作用:可以使用下标获取字符串中某个位置的字符
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最后一个字符,倒数第一个

切片

  • 切片:可以获取字符串中多个字符(多个字符的下标是有规律的,等差数列)

  • 语法

    字符串[sta rt:end:step]
    start是开始位置的下标,end是结束位置的下标(注意,不能取到这个位置的字符) step步长,等差数列的差值,所取的相邻字符下标之间的差值,默认是1,可以不写
    例:
    [1:5:1]#1 2 3 4
    [1:5:2]#1 3
    [1:5:3]#1 4
    [1:5:4]#1
    
    # 切片会得到一个字符串,即可以获取字符串中的多个字符
    str1 = 'abcdefg'
    # 1.获取abc字符
    print(str1[0:3:1])  # abc
    # 1.1如果步长是1可以不写,最后一个冒号也不写
    print(str1[0:3])  # abc
    # 1.2如果开始位置为0 ,可以不写,但是冒号必须有
    print(str1[:3])  # abc
    #3.获取aceg  # 0 2  4 6,所以步长为2
    print(str1[0:7:2]) # agceg
    print(str1[ ::2]) # agceg
    #4.特殊应用,步长为负数,开始和结束不写,意思全变,一般不用管,只有一种使用场景
    #反转(逆置)字符串字符串[::-1]
    print(str1[ ::-1])  #gfdcba
    

字符串的查找方法:

  • 字符串.find(sub_str, start,end)

  • 作用:在字符串中查找是否存在 sub_str这样的字符串

  • sub_str:要查找的小的字符串

  • start:开始位置,从哪个下标位置开始查找,一般不写,默认是0

  • end:结束位置,查找到哪个下标结束,一般不写,默认是len()

  • 返回(代码执行之后会得到什么,如果有返回,就可以使用变量保存):

    • 1.如果在字符串中找到了sub_str ,返回sub_str第一次出现的正数下标(sub_str中第一个字符在大字符串中的下标)
    • 2.如果没有找到,返回-1
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)

  • 将字符串中 old_str替换为new_str
    • old_str:被替换的内容
    • new_str:替换为的内容
    • count:替换的次数,一般不写,默认是全部替换
  • 返回:替换之后的完整的字符串,注意:原来的字符串没有发生改变

image-20220905195715372

字符串的拆分

  • 字符串.split(sep,maxsplit)
  • 将字符串按照sep进行分割(拆分)
    • sep,字符串按照什么进行拆分,默认是空白字符(空格,换行\n,tab键\t)
    • maxsplit,分割次数,一般不写,全部分割
    • 返回:将一个字符串拆分为多个,存到列表中
  • 注意:如果sep不写,想要指定分割次数则需要按照如下方式使用
    • 字符串.split(maxsplit=n) #n是次数

image-20220905202846948

字符串的链接join

  • 字符串.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

列表

  • 列表 list,是使用最多的一种容器(数据类型)
  • 列表中可以存储多个数据,每个数据之间使用逗号隔开
  • 列表中可以存放任意类型的数据

定义

# 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

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

  • 在字符串中使用的find方法查找下标的,不存在返回的是-1.
  • 在列表中没有find方法,想要查找数据的下标,使用的index()方法
  • 列表.index(数据,start,end)使用和 find方法一样,同时在字符串中也有index方法
  • 区别:返回
    • index()方法,找到返回第一次出现的下标,没有找到代码直接报错

查找 - 判断是否存在

  • 判断容器中某个数据是否存在可以使用 in 关键字
  • 数据 in 容器
    • 如果存在返回True ,如果不存在,返回False

查找 - 统计出现的次数

  • 统计出现的次数,使用的是 count() 方法
  • 列表.count(数据)
    • 返回数据出现的次数
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')

添加数据的方法

  • 尾部添加(最常用)

    列表.append(数据)   #将数据添加到列表的尾部
    
    返回:返回的 None(关键字,空),一般就不再使用 变量 来保存返回的内容想要查看添加后的列表,需要打印的是列表
    
  • 指定下标位置添加

    列表.insert(下标,数据)  #在指定的下标位置添加数据,如果指定的下标位置本来有数据,原数据会后移
    
    返回:返回的 None(关键字,空),一般就不再使用 变量 来保存返回的内容想要查看添加后的列表,需要打印的是列表
    
  • 列表合并

    列表1.extend(列表2) #将列表2中的所有数据逐个添加的列表1的尾部
    
    返回:返回的 None(关键字,空),一般就不再使用 变量 来保存返回的内容想要查看添加后的列表,需要打印的是列表
    

补充:列表推导式

  • 列表推导式:快速的生成列表
变量名 = [生成数据的规则 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 #代码会报错

删除操作

  • 在列表中删除中间的数据,那么后面的数据会向前移动

  • 根据下标删除

    列表.pop(下标)#删除指定下标位置对应的数据
    1.下标不写,默认删除最后一个数据(常用)
    2.书写存在的下标,删除对应下标位置的数据
    
    返回:返回的删除的数据
    
  • 根据数据值删除

    列表.remove(数据值)  # 根据数据值删除
    
    返回:None
    注意:如果要删除的数据不存在,会报错
    
  • 清空数据(一般不用)

    列表.clear()
    

列表的反转(倒置)

字符串中反转倒置:字符串[::-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)

列表嵌套

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

元组

  • 元组: tuple,元组的特点和列表非常相似
    1.元组中可以存放任意类型的数据
    2.元组中可以存放任意多个数据

  • 区别:
    1.元组中的数据内容不能改变,列表中的可以改变的
    2.元组使用(),列表使用[]

  • 应用:在函数的传参或者返回值中使用,保证数据不会被修改

定义

  • 1.使用类实例化的方式
    2.直接使用()方式

  • 特殊点:定义只有一个数据的元组时,数据后边必须有一个逗号

    my_tuple5 = (1,)
    print(my_tuple5)
    

常用方法

  • 由于元组中的数据不能修改,所以只有查看的方法
    • 1.在元组中也可以使用下标和切片获取数据
      2.在元组中存在index方法
      3.在元组中存在count方法
      4.在元组中可以使用in操作
    • 以上方法的使用和列表中一样的

字典

  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))

增加和修改操作

  • 语法:

    字典[键] = 数据值
    

    1.如果键已经存在,就是修改数据值
    2.如果键不存在,就是添加数据(即添加键值对)

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(键)#键必须书写
  • 清空

    字典.clear()
    
  • 字典.pop() 时,在pop的()中必须要填

    • my_dict.pop( 'age' )
    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 my_dict['sex']
    print(my_dict)  # {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '打游戏']}
    
    my_dict["like"].pop(0) # {'name': '小明', 'age': 19, 'like': ['喝酒', '烫头', '打游戏']}
    print(my_dict)
    
    my_dict["like"].remove("烫头")
    print(my_dict)
    
    my_dict.clear()
    print(my_dict)
    

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

  • 字典中没有下标的概念,想要获取数据值,要使用key(键)来获取

  • 使用 字典[键]

    字典[键]
    	1. 如果键存在返回键对应的数据值
    	2. 如果键不存在,会报错
    
  • 使用 字典.get(键)

    字典.get(键,数据值)
    	1.数据值一般不写,默认是None
    返回:
    	1.如果键存在,返回键对应的数据值
    	2,如果键不存在,返回的是括号中书写的数据值(None)
        
    一般建议使用get方法
    
    my_dict = {"name":"小明", "age": 18, "like": ['抽烟', '喝酒', '烫头']}
    
    print(my_dict.get('name'))
    
    print(my_dict.get('like')[1])  # 喝酒
    print(my_dict.get('sex'))  # None
    print(my_dict.get('sex','保密'))  # 保密
    

字典的遍历

对字典的键进行遍历

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. 函数必须先定义后调用

  • 语法

    def 函数名():
    	函数中的代码
    	函数中的代码
        
    # 1. def是关键字,用来定义函数的define的缩写
    # 2.函数名需要遵守标识符的规则
    # 3.处于def缩进中的代码,称为函数体
    # 4.函数定义的时候,函数体中的代码不会执行,在调用的时候才会执行
    
  • 函数定义小技巧

    • 在前期,书写不熟练的时候,

      1. 可以先不管函数,先把功能写出来
      2. 给多行代码起名字
      3. 选中多行代码,使用tab键进行缩进

函数的调用

  • 使用多行代码的时候,称为函数调用

  • 语法

    函数名()
    
    # 1.函数调用的时候会执行函数体中代码
    # 2.函数调用的代码,要写在函数体外边
    
    def say_hello():
        print( ' hello 1 ')
        print( ' hello 2 ')
        print( ' hello 3 ')
        
    #调用
    say_hello()
    say_hello()
    

文档注释

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

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

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

image-20220907112649184

函数的嵌套调用

  • 在一个函数定义中调用另一个函数
    1. 函数定义不会执行函数体中的代码
    2. 函数调用 会执行函数体中的代码
    3. 函数体中代码执行结束会回到函数被调用的地方继续向下执行
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('输入错误!')

  • 注意点:
    • get('登录'),然后遍历,循环的代码中用d.get(key)得到value,将结果保存到元组里
    • 在用列表的append方法,append(元组),添加每一次遍历的结果到列表中。

补充 - 列表去重

  • 列表去重:列表中存在多个数据,需求,去除列表中重复的数据

  • 方式1:思路

    • 遍历原列表中的数据判断在新列表中是否存在,如果存在,不管,如果不存在放入新的列表中
    • 遍历:for循环实现
    • 判断是否存在:可以使用 in
    • 存入数据:append()
  • 方法2:在Python中还有一种数据类型(容器),称为是集合(set)

    • 特点:集合中不能有重复的数据(如果有重复的数据会自动去重)
    • 可以使用集合的特点对列表去重
      1. 使用set()类型转换将列表转换为 集合类型
      2. 再使用list()类型转换将 集合 转换为 列表

    image-20220907162542651

    • 缺点:不能保证数据在原列表中出现的顺序(一般来说,也不考虑这件事)
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)
#目前书写的函数,在定义的时候如果有形参,那么在调用的时候,必须传递实参值,个数要对应,否则会报错
  • PEP8建议在函数的定义前后有两个空行,否则灰色波浪线提示

函数的返回值

  • 函数的返回值,可以理解为是函数整体执行的结果是什么

  • 什么情况需要书写返回值:函数中得到的数据在后续的代码中还要使用,这个时候就应该将这个数据作为返回值返回,以供后续使用

    print()---> None
    input( )---> 键盘输入的内容
    type() --->类型
    len() --->数据的长度(元素的个数)
    
  • 在函数中想要将一个数据作为返回值返回,需要使用 return 关键字(只能在函数中使用)

    • 作用:

      1.将数据值作为返回值返回
      2.函数代码执行遇到 return,会结束函数的执行
      
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)
  • 返回值的说明

    def 函数名():  #返回值None
    	pass   #代码中没有return
    
    def 函数名()∶
    	return   # return后边没有数据,返回值 None
    
    def函数名():
    	return xx   #返回值是xx
    

变量进阶[底层]

Python底层是如何处理数据?

变量的引用

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

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

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

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

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

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

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

image-20220907172429663

可变类型和不可变类型

  • 数据类型:int float bool str list tuple dict set

  • 可变不可变是指:数据所在的内存是否允许修改,允许修改就是可变类型,不允许修改就是不可变类型(不使用=,变量引用的数据中的内容是否会变化,会变化是可变的,不会变化是不可变的)

    可变类型:列表list,字典dict,集合set
    列表.append()
    字典.pop(键)
    不可变类型:int float bool str tuple
    

    image-20220907172841622

    my_list[1]=10  #这里修改的是列表中下标为1的位置的引
    print(id(my_lsit))  #列表的引用没有发生变化
    
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]))
  • 输出结果:

    my_list : 2189244740864 2189239648528
    my_list1: 2189244707584
    [1, 10, 3]
    my_list :  2189244740864 2189239648784
    (1, 2, [3, 4]) 2189244737024
    (1, 2, [10, 4]) 2189244737024
    

练习

  • 练习一

image-20220907174034231

  • 1.只有 = ,可以改变引用
    2.可变类型做参数,在函数内部,如果不使用= ** ,直接修改形参的引用,对形参进行的数据修改同步到实参**中

面试题 - 列表的 += 操作

  • 对于列表来说,+= 的 本质 是extend操作
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

  • 练习二 - 交换两个变量的值

    #方法三,重点掌握,Python特有
    a, b = b, a
    print(a, b)
    

组包和拆包

  • 组包(pack):将多个数据值使用逗号连接,组成元组
  • 拆包(unpack):将容器中的数据值使用多个变量分别保存的过程,注意:变量的个数和容器中数据的个数要保持一致
  • 赋值运算符,都是先执行等号右边的代码,执行的结果,保存到等号左边的变量中
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

局部变量和全局变量

  • 变量:根据变量的定义位置,可以将变量分为局部变量和全局变量

局部变量

  • 局部变量:在函数内部(函数的缩进中)定义的变量,称为是局部变量
  • 特点:
    1. 局部变量只能在当前函数内部使用,不能在其他函数和函数外部使用
    2. 在不同函数中,可以定义名字相同的局部变量,两者之间没有影响
    3. 生存周期(生命周期,作用范围) -->在哪能用
      • 在函数被调用的时候,局部变量被创建,函数调用结束,局部变量的值被销毁(删除),不能使用
      • 所以函数中的局部变量的值,如果想要在函数外部使用,需要使用 return 关键字,将这个值进行返回
def func1():
num = 10 # num就是局部变量
print(f"func1函数中{num}")

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

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

全局变量

  • 定义位置:在函数外部定义的变量,称为是全局变量特点:
    1. 可以在任何函数中读取(获取)全局变量的值
    2. 如何在函数中存在和全局变量名字相同的局部变量,在函数中使用的是局部变量的值(就近)
    3. 在函数内部想要修改全局变量的引用,需要添加 global 关键字,对变量进行声明为全局变量
    4. 生命周期
      代码执行的时候被创建,代码执行结束,被销毁(删除)
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)

函数进阶

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

  • 函数中想要返回一个数据值,使用return关键字
  • 多个数据值组成容器进行返回,一般是元组(组包)
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)

函数参数

  • 形参的不同书写方法

函数传参的方式

  • 位置传参:

    • 在函数调用的时候,按照形参的顺序,将实参值传递给形参
  • 关键字传参

    • 在函数调用的时候,指定数据值给到那个形参
  • 混合使用

    1. 关键字传参必须写在位置传参的后面
    2. 不要给一个形参传递多个数据值
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)

缺省参数

  • 缺省参数,默认参数

  • 列表.pop() # 不写参数,删除最后一个

  • 列表.sort( reverse=True)

  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)

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

  • 不定长位置参数(不定长元组参数)

    1. 书写:在普通参数的前边,加上一个 *,这个参数就变为不定长位置参数

    2. 特点,这个形参可以接收任意多个 位置传参 的数据

    3. 数据类型,形参的类型是 元组

    4. 注意,不定长位置参数要写在普通的参数的后面

    5. 一般写法,不定长位置参数的名字为args,即(*args) arguments

  • 不定长关键字参数(不定长字典参数)

    1. 书写:在普通参数的前边,加上两个 **,这个参数就变为不定长关键字参数

    2. 特点,这个形参可以接收任意多个 关键字传参 的数据

    3. 数据类型,形参的类型是 字典

    4. 注意,不定长关键字参数要写在所有参数后面

    5. 一般写法,不定长位置参数的名字为 kwargs,即(**kwargs) keyword arguments

  • 完整的参数顺序

    def 函数名(普通函数,*args,缺省参数,**kwargs):
        pass
    
    #一般在使用的时候,使用1-2种,按照这个顺序挑选书写即可
    
  • 例子:

    def func(*args, **kwargs):
        print(type(args),args)
        print(type(kwargs),kwargs)
        print('-'*30)
    
    
    func()
    func(1, 2, 3)
    func(a=1, b=2, c=3)
    func(4,5,6,a=1, b=2, c=3)  # <class 'tuple'> (4, 5, 6)   <class 'dict'> {'a': 1, 'b': 2, 'c': 3}
    
    • 遍历:
    def func(*args, **kwargs):
        print(type(args),args)
        print(type(kwargs),kwargs)
        for i in args:
            print(i)
        for j in kwargs.values():
            print(j)
        print('-'*30)
    
    
    func(1,2,3)
    func(a=1,b=2,c=3)
    
  • sep = ' '

    • 多个位置参数之间的间隔

      print(1,2,3,4,5)  # 1 2 3 4 5
      print(1,2,3,4,5,sep = '_')   # 1_2_3_4_5
      
  • end = ' \n'

    • 每一个 print 函数结束,都会打印的内容 结束符 -- 换行

    • 不想换行 -- end = ' '

      print(1,end=' ')
      print(2,end=' ')
      print(3)               # 1 2 3
      

练习

  • 题目一

    定义一个函数my_sum,函数的功能是可以对任意多个数字进行求和计算。

    def my_sum(*args):
        num = sum(args)
        return num
    

不定长参数补充

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)

匿名函数

  • 匿名函数:就是使用lambda关键字定义的函数

    • 一般称为使用def 关键字定义的函数为,标准函数
  • 匿名函数只能书写一行代码

  • 匿名函数的返回值不需要 return ,一行代码(表达式) 的结果就是返回值

  • 语法:

    lambda 参数: 一行代码
    
    # 匿名函数一般不需要我们主动的调用,一般作为函数的参数使用的
    #我们在学习阶段为了查看匿名函数定义的是否正确,可以调用
    
    # 1.在定义的时候,将匿名函数的引用保存到一个变量中
    变量= lambda参数:一行代码
    # 2.使用变量进行调用
    变量()
    
  • 代码

    # 1.无参无返回值
    def func1():
        print('hello world')
    
    
    func1()
    # Lambda : print( " hello lambda ')
    # 匿名函数的定义
    func11 = lambda: print('hello lambda')
    func11()
    
    
    # 2.无参有返回值
    def func2():
        return 10
    
    
    print(func2())
    
    func22 = lambda: 10
    print(func22())
    
    
    # 3.有参无返回值
    def my_sum(a, b):
        print(a + b)
    
    
    my_sum(1, 2)
    my_sum11 = lambda a, b: print(a + b)
    my_sum11(10, 20)
    
    
    # 4.有参有返回值
    def func4(a, b):
        return a + b
    
    
    print(func4(1, 2))  # num = func4(1,2)  print(num)
    
    func4 = lambda a, b: a + b
    print(func4(10, 20))
    

练习

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))
  • 匿名函数作为函数的参数 - 列表中的字典排序

    user_list = [
    {"name": "zhangsan", "age": 18},{ "name": "lisi","age": 19},{ "name":"wangwu","age": 17}
    ]
    
    列表排序(列表中的数字): 列表.sort() #升序
    列表.sort(reverse=True)  #降序列表中的内容都是字典,想要排序?
    
  • user_list.sort()

    • 列表的排序,默认是对列表中的数据进行比大小的,可以对数字类型和字符串进行比大小,

    • 但是对于字典来说,就不知道该怎么比大小,此时,我们需要使用 sort函数中的 key 这个参数,来指定字典比大小的方法

    • key这个参数,需要传递一个函数,一般是匿名函数,字典的排序,其实要指定根据字典的什么、进行排序,我们只需要使用 ---> 匿名函数返回字典的这个键对应的值即可

      列表.sort( key=lambda x: ×['键'])
      
  • 代码:

    user_list = [
    {"name": "zhangsan", "age": 18},{ "name": "lisi","age": 19},{ "name":"wangwu","age": 17}
    ]
    
    user_list.sort(key=lambda x: x['age'])
    print(user_list)
    
    user_list.sort(key=lambda x: x['age'],reverse=True)
    print(user_list)
    
  • 说明:匿名函数中的参数是列表中的数据,在 sort函数内部,会调用key这个函数(将列表中每个数据作为实参传递给形参),#从列表中的获取函数的返回值,对返回值进行比大小操作(<)

  • 字符串比大小

    • 字符比大小,是比较字符对应的ASCII码值
    • A< Z < a < z
    ord(字符)   # 获取字符对应的ASCII的值
    chr(ASCII值)  # 获取对应的字符
    
    字符串比大小:
    对应下标位置字符的大小,直到比出大小,如果全部比完了,还没有比出大小,就是相等
    

image-20220909091756974

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

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有