Python_1（面向对象前）

Python

创建文件书写代码

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

运行代码

注释

• # ：单行注释（井号+空格）

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

  • 一般写在文件的最开始部分,或者文档注释处(函数）

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

• 快捷键：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．你要转换为什么类型
  

• 注意点：数据类型转换,不会改变原来的数据的类型，会生成一个新的数据类型

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

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

  2．可以将整数类型的字符串：3、123

• 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回车

运算符

算数运算符

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

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

比较运算符

• 比较运算符得到都是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

赋值运算符

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

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

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调试查看代码执行过程，解决方案,在代码其他任意地方多加一个断点

2. 右键debug运行代码

3. 单步执行代码

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 关键字前边的变量中
  

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:替换的次数,一般不写,默认是全部替换
• 返回:替换之后的完整的字符串，注意:原来的字符串没有发生改变

字符串的拆分

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

字符串的链接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

列表

定义

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

添加

列表.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）鼠标左键点击)

函数的嵌套调用

• 在一个函数定义中调用另一个函数
  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

练习

• 练习一

有如下列表:
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()类型转换将 集合 转换为 列表
  • 缺点：不能保证数据在原列表中出现的顺序(一般来说，也不考虑这件事)

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中数据的传递,都是传递的引用

可变类型和不可变类型

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

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

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

  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
  

练习

• 练习一

• 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]

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

  #方法三，重点掌握,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)
  

print 函数

• 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值)  # 获取对应的字符
  
  字符串比大小:
  对应下标位置字符的大小，直到比出大小，如果全部比完了，还没有比出大小,就是相等