python基础语法

python基础语法

字符串

字符串（string），又称文本，是由任意数量的字符入中文，英文，各类符号，数字等组成，所以叫字符串

“sadg”
“asdf”
“北京大学”

python中，字符串都是需要使用 ‘’包围起来，被 ''包围起来的都是字符串

1. 什么是字面量

在代码中，被写在代码中的固定值，称之为字面量

2. 常见字面量的类型

我们目前了解，整数、浮点数、字符串、三类

3. 如何基于print语句完成各类字面量的输出

print(字面量)，如:
print(10)，输出整数10
print(13.14)，输出浮点数13.14
print("黑马程序员")，输出字符串:黑马程序员

注释

在程序代码中华对程序代码进行解释说明的文字

• 单行注释：以#开头，#右边 的所以文字当做说明，而不是真正的要执行1程序，起说明的辅助作用

  • # 我是单行注释
    print("Hello World")
    

• 多行注释：以一对三个双引号引起来（“”“注释内容”“”）来解释一段代码的作用使用方法

  """
  本代码然是了：
  - 各类字面量的写法
  - 通过print语句输出各类字面量
  """
  

1. 注释的作用？

注释是代码中的解释型语句，用来对代码内容进行注释

注释不是代码，不会被程序执行

2. 单行注释如何定义

通过#号定义，在#号右侧的所以内容均作为注释

建议在#和注释内容之间，间隔一个空格

单行注释一般作用于对一行或一小部分代码进行解释

3. 多行注释如何定义

通过一对三个引号来定义("""注释内容""")，引号内部均是注释，可以换

变量

什么是变量？

变量：在程序运行时，能储存计算结果或能表示值的抽象概念

简单来说，变量就是在程序运行时，记录数据用的

money = 50
print("钱包还有：",money)

1. 变量是什么，有什么作用？

变量就是在程序运行时，记录数据用的

2. 变量的定义格式是？

变量名 = 变量值

3. 变量的特征是？

变量值可以改变

4. print语句如何输出多份内容？

print(内容1，内容2，......，内容N)

5. Python中如何做减法？

使用符号 - 既可完成建发运算

拓展：加（+）、减（-）、乘（*）、除（/）

数据类型

string int float 这三个英文单词，就是类型的标准名称

使用type语句查看数据的类型

type语句使用方式

1. 在print语句中，直接输出类型信息：

print(type("这是一段字符串"))
print(type(666))
print(type(11.34))

<class 'str'>
<class 'int'>
<class 'float'>

2. 用变量存储type()的结果（返回值）

string_type = type("这是一段字符串")
int_type = type(666)
float_type = type(11.45)
print(string_type)
print(int_type)
print(float_type)

<class 'str'>
<class 'int'>
<class 'float'>

3. type语句可以查看变量中存储的数据类型

name = "这是段字符串"
name_type = type(name)
print(name_type)

<class 'str'>

我们可以通过type（变量）可以输出类型，这是因为查看变量的类型还是数据的类型？

查看的是：变量的存储的数据类型，因为，变量无类型，但是他有存储的数据有

常见的转换语句

字符串、整数、浮点数、类型转换的语句是

# 将数字类型转成字符串
num_str = str(11)
print(type(num_str),num_str)

#浮点数转成字符串
float_str = str(11.345)
print(type(float_str),float_str)

#将字符串转成数字
num = int("11")
print(type(num),num)

#错误示例，想要将字符串转成数字，必须要求字符串内的内容都是数字
# num3 = int("字符串")
# print(type(num3),num3)

# 证书转浮点数
float_num = float(11)
print(type(float_num),float_str)

# 浮点数转整数
int_num = int(11.345)
print(type(int_num),int_num)

注意

1. 任何类型都可以转成字符串
2. 不是所有字符串都可以转成数字，字符串内必须只有数字才行
3. 浮点数转整数会丢失精度

标识符

Python，标识符命名的规则主要有三类

1. 内容限定

• 在标识符命令里面只允许出现
  • 英文
  • 中文
  • 数字
  • 下划线(_)

# 错误代码示范 ： 1_name = "张山"
# 错误代码示范 ： name_! = "张三cxc"
name_ = '张三'
_name = '张三'
name_1 = "张三"

2. 大小写铭感

   • 在python里面是区分大小写的

   Itheima = "字符串"
   itheima = 666
   
   print(Itheima)
   print(itheima)
   

3. 不可使用关键字

   • python中有一系列单词，称之为关键字，关键字在python中都有特定用途，我们不可以使用它作为 标识符

运算符

# 算数运算符
print("1 + 1=", 1 + 1)
print("2 - 1=", 2 - 1 )
print("3 * 3=", 3 * 3 )
print("4 / 2 = ", 4 /2 )
print("11//2 = ",11//2)
print("9%2=",9%2)
print("2 ** 2=", 2**2)

# 赋值运算符
num = 1+2*3

# 复合赋值运算符
# +=
num = 1
num += 1 # num = num +1
print("num += 1:",num)
num -=1
print("num -= 1:",num)
num *=4
print("num *= 4:",num)
num /=2
print("num /=2:",num)
num =3
num %=2
print("num %=2:",num)

num **=2
print("num **=2:",num)
num =9
num //=2
print("num // =2:",num)

1. 常见的算数运算符有：

加（+）、减（-），乘（*）、除（/），整除（//）、取余（%）、平方（**）

2. 赋值运算符有：

• 标准赋值：=
• 复合赋值： +=、-=、*=、/=、//=、%=、**=

字符串的三种定义方法

1. 单引号定义法

2. 双引号定义法

3. 三引号定义法

name = '这是一段文字' #单引号定义法，使用单引号进行包围
print(type(name))

name = "这是一段文字"  # 双引号定义法

name = """
这是
一段
文字
"""

如果我想要定义的字符串本身，是包含：单引号、双引号自身呢？如何写？

• 单引号定义法，可以内含双引号
• 双引号定义法，可以内含单引号
• 可以使用转移字符（\）来将引号解除效用，变成普通字符串

name = '"单引号里面有双引号"'
name = “‘双引号里面有单引号’”
name = ""\解除引号效用"
name = ‘\‘解除引号效用’\’

字符串拼接

# 字符串字面量之间的拼接
print("这是一段文字"+"和语句")
# 字符串字面量和字符串变量的凭借
name = "这是一句话"
address = "解放路69号"
tel = 40003532
print("我打的"+name+"address")

#如果加上tel会报错
print("我打的"+name+"address"+"我的地址是："+tel)
#字符串是没有办法通过+和变量进行拼接的

字符串格式化

通过占位的形式，完成拼接

name ="这是一段文字"
message ="这是一句话和 %s" % name
print(message)

其中的,%s

• % 表示：我要占位
• s 表示：将变量变成字符串放入占位的地方

所以，综合起来意思就是：我先占一个位置，等会有有个变量过来吗，我把它变成字符串放入到占位的位子

通过占位的形式，完成数字和字符串的拼接

class_num =57
avg_salary= 16781
message = "网安网络安全学科，北京%s期,毕业平均工资：%s" % (class_num,avg_salary)
print(message)

python支持非常多的数据类型占位
最常用的是如下三类

name="Hacker"
set_up_year = 2004
stock_price = 10.11
message = "我是：%s,我成立于：%d,我今天的股价是：%f"%(name,set_up_year,stock_price)
print(message)

1. 字符串格式化语法？

%占位符，%变量

2. 常用占位符有哪三个

%s，%d，%f

格式化字符串的精度控制

我们可以使用辅助符号“m.n”来控制数据的宽度和精度

• m,控制宽度，要求是数字（很少使用），设置的宽度小于数字自身，不生效
• n,控制小数点精度,要求是数字,会进行小数的四舍五入

示例:

• %5d:表示将整数的宽度控制在5位，如11，被设置为5d，就会变成：[][][空格] [空格] [空格] 11,用三个空格补足宽度

• %5.2f:表示将宽度控制为5，将小数点精度设置为2

  小数点和小数部分也算入宽度计算。如，对11.345设置了%7.2f后，结果是:[空格] [空格]11.35。2个空格补足宽度，小数部分限制2位精度后，四舍五入为.35

• %.2f:表示不限制宽度，只设置小数点精度为2，如11.345设置%.2f后，结果是11.35

num1 =11
num2 = 11.345
print("数字11宽度限制5,结果是：%5d"% num1)
print("数字11宽度限制1,结果是：%1d"% num1)
print("数字11.345宽度限制7,结果是：%7.2f" % num2)
print("数字11宽度限制5,结果是：%.2f"% num2)

1. 精度控制的语法是:
   m.n的形式控制，如%5d、%5.2f、%.2f
   m和.n均可省略
2. 如果m比数字本身宽度还小，会发生什么事?
   m不生效
3. .n会对小数部分做精度限制，同时:?
   会对小数部分做四舍五入

快速格式化

通过语法：f "内容{变量}"的格式来快速格式化

name = "Hacker"
set_up_year = 2004
stock_price = 19.99
print(f"我是{name},我成立于,{set_up_year},我今天的股价是:{stock_price}")

1. 可以通过
   (变量}{变量}”的方式进行快速格式化

2. 这种方式:
   不理会类型
   不做精度控制
   适合对精度没有要求的时候快速使用

对表达式进行格式化

表达式：一条具有明确执行结果的代码语句

print("1*1 的结果是:%d"%(1*1))
print(f"1*2的结果是：{1*2}")
print("字符串在python中的裂隙名是：%s"% type("字符串"))

1.表达式是什么?
表达式就是一个具有明确结果的代码语，如1+1、类型(““夺串等:*5 在变量定义的时候，如age=11+11等号右侧的就是表达式，也就是有具体的结果，将结果赋值给了等号左侧的变量

2.如何格式化表达式?

• f“{表达式}”
• “%s%d%f”%(表达式、表达式、表达式)

课后作业

name= "HackTheBox"
stock_price =19.22
stock_code = 114514
stock_price_daliy_growth_factor = 1.2
growth_days = 7
print(f"我是{name},股票代码：{stock_code},当前股价:{stock_price}")
print("每日增长系数是:%.1f,经过%d天的增长后，股价到达了%.2f"%(stock_price_daliy_growth_factor,growth_days,(stock_price * stock_price_daliy_growth_factor ** growth_days)))

数据输入

# 获取键盘输入
name = input("请你告诉我你是谁")
print("我知道了，你的%s"% name)

# 输入数字类型
num = input("请在键盘上输入数字")
# input默认类型是stt 如果需要整数请进行格式转换
num = int(num)
print("你的银行卡密码类型是", type(num))

1.input()语句的功能是，获取键盘输入的数据

2.可以使用:input(提示信息。者输入内容之前显示提示

3.要注意，无论键盘输符串类型获取到的数据永远都是字

课后作业

user_name = input("请您输入你的用户名")
user_tupe = input("请您输入你的登记")
print(f"您好{user_name}，您是尊贵的：{user_tupe}用户,欢迎您的光临")

布尔类型和比较运算符

布尔类型的字面量:

• True 表示真(是、肯定)
• False 表示假 (否、否定)

定义变量存储布尔类型数据：

变量名称 =布尔类型字面量

布尔类型不仅可以自行定义，同时也可以通过计算的来。也就是使用比较运算符进行比较运算得到布尔类型的结果。

1.在Python中，可以表示真假的数据类型是布尔类型，字面量True表示真，字面量False表示假

2.除了可以定义布尔类型外，还可以通过比较运算符计算得到布尔类型
通过<比较运算符>计算得到布尔类型的结果==判断是否相等，!=判断是否不相等

== 判断是否相等，！=判断是否不相等

判断是否大于，<判断是否小于

判断是否小干等

if语句的基本格式

age =18
if age >= 18:
    print("我已经成年了")
    print("即将步入大学生活")

print("时间过得真快啊")

判断语句的结果,必须是布尔类型True或者Flase

True会执行if内的代码语句

False不会执行

练习案例:成年人判断
结合前面学习的input输入语句，完成如下案例:
1.通过input语句，获取键盘输入，为变量age赋值。(注意转换成数字类型)2.通过if判断是否是成年人，满足条件则输出提示信息，如下:欢迎来到黑马儿童游乐场，儿童免费，成人收费请输入你的年龄:30
您已成年，游玩需要补票10元。
祝您游玩愉快。

print("欢迎来到游乐园，儿童免费，成人收费")
age = int(input("请输入你的年龄:"))
if age > 18:
    print("您已经年满18，游玩需要补票十元")
print("祝您游玩愉快")

if else语句

print("欢迎来到游乐园，儿童免费，成人收费")
age = int(input("请输入你的年龄:"))
if age > 18:
    print("您已经年满18，游玩需要补票十元")
else:
    print("您未成年可以免费游玩")
print("祝您游玩愉快")

1. if else 语句，其中

• if 和其他代码快，条件满足时执行
• else 搭配if的判断条件，当不满足的时候执行

2. if else语句的注意事项

• else 不需要判断条件，当if的条件不满足时，else执行
• else的代码快，同样需要4个空格作为缩进

练习案例:我要买票吗
通过input语句获取键盘输入的身高判断身高是否超过120cm，并通过print给出提示信息，
欢迎来到黑马动物园。
请输入你的身高(cm):130您的身高超出120cm，游玩需要够票10元。祝您游玩愉快。
欢迎来到黑马动物园
请输入你的身高(cm):111您的身高未超出120cm，可以免费游玩祝您游玩愉快。

print("欢迎来到黑马动物园")
tal = int(input("请输入你的身高(cm)："))
if tal>120:
    print("您的身高超出120cm，游玩需要购票10元")
else:
    print("您的身高未超过120cm，您可以免费游玩")

print("祝您游玩愉快")

if elif else语句

print("欢迎来到黑马动物园")
if  int(input("请输入你的身高(cm)："))<120:
    print("您的身高小于120cm，可以免费游玩")

elif int(input("请输入你的vip等级(1~5):"))> 3:
    print("您的VIP等级大于3级可以免费游玩.")
else:
    print("您的所以条件都不满足,需要购票10元")

print("祝您游玩愉快")

1. if,elif,else语句的作用是什么

可以完成多个条件判断

2. 使用 if elif else注意的点有

• elif可以写多个语句
• 判断是互斥且有序的，上一个满足后面就不会判断了
• 可以在条件判断语句中,直接写input语句，节省代码量

练习案例:猜猜心里数字

1.定义一个变量，数字类型，内容随意2.基于input语句输入猜想的数字，通过if和多次elif的组合，判断猜想数字是否和心里数字一致。D:dev\pythonlpython3.10.4\python请输入第一次猜想的数字:1
不对，再猜一次:2
不对，再猜最后一次:3
Sorry，全部猜错啦，我想的是:10

if int(input("请你输入第一次猜想的数字:")) == 100:
    print("恭喜你猜对了")
elif int(input("不对,再猜一次:")) == 100:
    print("恭喜你猜对了")
elif int(input("不对,再猜最后一次:")) == 100:
    print("恭喜你猜对了")
else :
    print("Sorry,全部猜错了,我想的是：100")

判断语句嵌套

if int(input("请输入你的年龄")) > 18:
    print("您是成年人")
    if int(input("请输入你的年龄:")) <30:
        print("满足条件继续判断：")
        if int(input("请输入你的入职年龄:")) > 2:
            print("恭喜你获得公司发放的礼物")
        elif int(input("请输入您当前的级别:")) > 3:
            print("恭喜你获得公司发放的礼物")
        else:
            print("您不符合要求，无法获得公司礼物")

    else :
        print("您不符合要求，无法获得公司礼物")

else :
    print("您不符合要求，无法获得公司礼物")

1.嵌套判断语句可以用于多条件、多层次的逻辑判断

2.嵌套判断语句可以根据需求，自由组合ifelifelse来
构建多层次判断

3.嵌套判断语句，一定要注意空格缩进，Python通过
空格缩进来决定层次关系

实战案例

案例需求:
定义一个数字随机产生)，通过3次判断来猜出来数字
案例要求:
数字随机产生，范围1-10
一ao有3次机会猜测数字，通过3层嵌套判断实现每次猜不中，会提示大了或小了
提示，通过如下代码，可以定义一个变量num，变量内存储随机数字。

import randomnum = random.randint(1，10)

import random
num = random.randint(1,10)
num1 = int(input("请输入第一次要猜的数字"))
if num1 != num:
    if num1 > num:
        print("猜大了")
        num2 =  int(input("请输入第二次要猜的数字"))
        if num2 != num:
            if num2 > num:
                print("猜大了")
                num3 = int(input("请输入第三次要猜的数字"))
                if num3 != num:
                    print("您已经用完所以次数了")
                else:
                    print("恭喜你猜对了")

            elif num2 < num:
                print("猜小了")
                num3 = int(input("请输入第三次要猜的数字"))
                if num3 != num:
                    print("您已经用完所以次数了")
                else:
                    print("恭喜你猜对了")
        else:
            print("恭喜你猜对了")
    elif num1 < num :
        print("猜小了")
        num2 = int(input("请输入第二次要猜的数字"))
        if num2 != num:
            if num2 > num:
                print("猜大了")
                num3 = int(input("请输入第三次要猜的数字"))
                if num3 != num:
                    print("您已经用完所以次数了")
                else:
                    print("恭喜你猜对了")

            elif num2 < num:
                print("猜小了")
                num3 = int(input("请输入第三次要猜的数字"))
                if num3 != num:
                    print("您已经用完所以次数了")
                else:
                    print("恭喜你猜对了")
        else:
            print("恭喜你猜对了")
else:
    print("恭喜你猜对了")

while 循环的基础语法

i =0
while i<100:
    print("LKX 我喜欢你")
    i +=1

1.while的条件需得到布尔类型，True表示继续循环，False表示结束循环
2.需要设置循环终止的条件，如i +=1配合i<100，就能确保100次后停止，否则将无限循环
3.空格缩进和if判断一样，都需要设置

练习案例:求1-100的和
需求:通过while循环计算从11累加到100的和

提示:终止条件不要忘记，，设置为确保while循环100次，确保累加的数字，从1开始，到100结束

i = 1
sum = 0
while i <=100:
    sum += i
    i += 1
print(sum)

while 循环的基础案例

import random
num = random.randint(1,100)
count = 0
flag = True
while flag:
    guess_num = int(input("请你输入你猜测的数字："))
    count +=1
    if guess_num == num:
        print("猜中了")
        flag = False
    else:
        if guess_num > num:
            print("你猜的大了")
        else:
            print("你猜小了")
print(f"你总共猜测了{count}次")

while循环的嵌套应用

i =1
while i<=520:
    print(f"今天是第{i},准备表白")
    j =1
    while j<=10:
        print(f"送给LKX的第{j}只玫瑰花")
        j+=1
    print("LKX我喜欢你")
    i +=1
print(f"坚持到第{i-1}天,表白成功")

1.嵌套循环的语法格式:
见右图
2.嵌套循环需要注意的地方:

• 注意条件的控制，避免无限循环
• 多层嵌套，主要空格缩进来确定层次关系

3.嵌套循环的使用难点

• 需要细心+耐心循环条件的控制，层次越多越复杂

while循环的嵌套案例

i =1
while i<=9:
    j = 1
    while j <= i:
         print(f"{j}*{i} ={j*i}\t", end = '')
         j += 1
    i+=1
    print()

for循环的基础语法

基础

name = "IloveYou"
for x in  name:
    print(x)

1. for循环的语法格式是:

   for 临时变量 in 待处理数据集 （序列）:
   	循环满足条配件时执行的代码
   

2. for 循环的注意点

   • 无法定义循环条件，只能被动取出所以数据
   • 需要注意，循环内的语句，需要有空格缩进

rang

语法中：待处理数据集，严格来说称之为：序列类型

序列类型指，其内容可以一个一个依次取出的一种类型，包括

• 字符串
• 列表
• 元祖
• 等

for循环的本质是遍历：序列类型

语法1：

range(num)

获取一个从0开始，到num结束的数字序列(不含num本身)

如range(5)取得的数据是:[0,1,2,3,4]

语法2:
range(num1，num2)获得一个从num1开始，到num2结束的数字序列(不含num2本身)

如，range(5,10)取得的数据是:[5,6,7,8,9]

语法3:
range(num1,num2,step)获得一个从num1开始，到num2结束的数字序列(不含num2本身)

数字之间的步长，以step为准(step默认为1)

如，range(5,10,2)取得的数据是:[5,7,9]

# 语法一
 for x in  range(10):
     print(x)

#语法二
 for x in  range(5,10):
     print(x)

#语法三
for x in range(5,10,2):
    print(x)

for循环的嵌套应用

for i in range(1,10):
    for j in range(1,i+1):
        print(f"{i}*{j}={j*i}\t",end= '')
    print()

循环中断：break和continue

continue

for i in range(1,100):
	语句1
	for j in range(1,100):
		语句2
		contine
		语句3
	语句4

continue 关键字只可以控制：它所在的循环临时中断

break

for i in rnage(1,100):
	语句1
	break
	语句2
语句3

break 关键字用于：直接结束循环

break可以用于：for循环和while循环，效果一致

1. contine的作用是：

中断所在循环的当次执行，直接进入下一次

2. break的作用是

结束坐在循环

3. 注意事项

• continue和break，在for和while循环中作用一致
• 在嵌套循环中，只能作用在所在的循环上，无法对上层循环
  起作用

综合案例

练习案例:发工资
某公司，账户余额有1W元，给20名员工发工资。
员工编号从1到20，从编号1开始，依次领取工资，每人可领取1000元领工资时，财务判断员工的绩效分(1-10)(随机生成)，如果低于5，不发工资，换下一位，结束发工资如果工资发完

import  random
Balance = 10000
for i in range(1,21):
    num = random.randint(1, 10)
    if num < 5:
        print(f"员工{i}绩效分{num}，低于5分，不发工资，下一位")
        continue
    elif Balance >= 1000:
        Balance -=1000
        print(f"向员工{i}发工资1000元，账户余额还剩{Balance}元")
        continue
    else:
        print("工资发完")
        break

函数

str1 ="ithema"
str2 = "IloveYou"
str3 = "IlikeYou"
def my_len(data):
    count = 0
    for i in str1:
        count+=1
    print(f"字符串{data}的长度是:{count}")

my_len(str1)
my_len(str2)
my_len(str3)

字符串ithema的长度是:6
字符串IloveYou的长度是:6
字符串IlikeYou的长度是:6

1. 函数是
   • 组织好的，是重复使用的，是用来实现特定功能的代码片段
2. 使用函数的功能是：
   • 将封装在函数内，可供随时地重复利用
   • 提高代码的重复性，减少重复代码，提高开发效率

函数的定义

def hacker():
    print("HI 我是HACKER")
hacker()

1. 函数的定义语法

def 函数名(传入的参数):  
	函数名
	return 返回值

2.函数的使用·步骤

• 先定义函数
• 后调用函数

3.注意事项

• 参数不需要可以省略
• 返回值不需要，可以省略

函数的传入参数

def add(x,y):
    result = x + y
    print(f"{x}+{y}的结果是:{result}")

add(5,6)

语法解析

• 函数定义中，提供的x和y，称之为:形式参数(形参)，表示函数声明将要使用2个参数

  • 参数之间使用逗号进行分隔

• 函数调用中，提供的5和6，称之为:实际参数(实参)，表示函数执行时真正使用的参数值

  • 传入的时候，按照顺序传入数据，使用逗号分隔

练习案例:升级版自动查核酸
定义一个函数，名称任意，并接受一个参数传入(数字类型，表示体温，在函数内进行体温判断(正常范围:小于等于37.5度)，并输出如下内容:欢迎来到黑马程序员!请出示您的健康码以及72小时核酸证明，并配合测量体温!体温测量中，您的体温是:37.3度，体温正常请进!
欢迎来到黑马程序员!请出示您的健康码以及72小时核酸证明，并配合测量体温体温测量中，您的体温是:39.3度，需要隔离!

def check(num):
    if num <= 37.5:
        print(f"欢迎来到xxx,请你出示您的健康码以及72小时核酸证明,并配合测量体温！\n体温测量中您的体温是{num}，体温正常请您正常进入")
    else:
        print(f"欢迎来到xxx,请你出示您的健康码以及72小时核酸证明,并配合测量体温！\n体温测量中您的体温是{num},需要隔离")

check(int(input("请输入你的体温")))

函数返回值

def add(a,b):
    result = a+b
    return  result
sum = add(1,2)
print(sum)

如图代码
定义两数相加的函数功能。完成功能后，会将相加的结果返回给函数调用者所以，变量r接收到了函数的执行结果。

综上所述
所谓“返回值就是程序中函数完成事情后，最后给调用者的结果

函数体在遇到return后就结束了，所以写在return后的代码不会执行

函数返回值None

def check_age(age):
    if age > 18:
        return "SUCCESS"
    else:
        return  None
result = check_age(16)
if not  result:
    print("未成年，不可以进入")
    
#None用于声明无初始内容的变量
name =None

1.什么是None

• None是类型'NoneType'的字面量用于表示:空的、无意义的

2.函数如何返回None

• 不使用return语句即返回None
• 主动return None

3.使用场景

• 函数返回值
• if判断
• 变量定义

函数的说明文档

def add(x,y):
    """
    add函数可以接受两个参数，进行2数相加的功能
    :param x: 形参x表示相加的其中一个数字
    :param y: 形参y表示相加的另外一个数字
    :return: 返回值2数是相加的结果
    """
    result = x + y
    return result
r = add(4,5)

函数嵌套调用

def func_b():
    print("---2---")

def func_a():
    print("---1---")

    func_b()

    print("---3---")

func_a()

1.什么是嵌套调用
在一个函数中，调用另外一个函数

2.执行流程
函数A中执行到调用函数B的语句，会将函数B全部执行完成后，继续执行函数A的剩余内容

变量在函数作用域中的作用

主要分为两类:局部变量和全局变量

局部变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效

def test_a():
    num  =100
    print(num)

test_a()
print(num)

变量a是定义在`testA函数内部的变量，在函数外部访问则立即报错

局部变量的作用:在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量

全局变量

num = 20
def test_a():
    print(f"tesa_a:{num}")

def test_b():
    print(f"test_b:{num}")
test_b()
test_a()
print(num)

在函数内外部都可以使用

在函数内修改全局变量

num = 20
def test_a():
    print(f"tesa_a:{num}")

def test_b():
    global num
    num = 500
    print(f"test_b:{num}")
test_b()
test_a()
print(num)



test_b:500
tesa_a:500
500

综合案例

name = input("请输入您的姓名：")
money = 5000000


def query():
    print("--------------------查询余额--------------------")
    print(f"{name}你的余额为{money}")


def Deposit(num):
    global money
    money += num
    print("--------------------存款--------------------")
    print(f"您存款{num}成功")
    print(f"{name}您当前的余额为:{money}")


def Withdrawal(num):
    global money
    if num > money:
        print("余额不足，取款失败!")
    else:
        money -= num
        print("--------------------取款--------------------")
        print(f"{name}您取款{num}成功")
        print(f"{name}您当前的余额为:{money}")


def main():
    print("--------------------菜单--------------------")
    print(f"{name}您好，欢迎来到Hacker银行，请选择你的操作")
    print("查询余额  [请输入1]")
    print("存款      [请输入2]")
    print("取款      [请输入3]")
    print("退出      [请输入4]")


while True:
    main()
    choice = int(input("请输入你的选择:"))

    if choice == 1:
        query()
    elif choice == 2:
        num = int(input("您想要存多少钱，请输入："))
        Deposit(num)
    elif choice == 3:
        num = int(input("您想要取多少钱，请输入："))
        Withdrawal(num)
    elif choice == 4:
        print("程序退出啦")
        break
    else:
        print("输入错误，请重新输入！")

数据容器入门

1. Python中的数据容器

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

2.Python有哪些数据容器?
list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)它们各有特点，但都满足可容纳多个元素的特性。

数据容器：list列表

定义列表

# 定义一个列表list
my_list = ["itheima","itcast","python"]
print(my_list)
print(type(my_list))

my_list = ["itheima","666","True"]
print(my_list)
print(type(my_list))

# 定义一个嵌套列表
my_list = [[1,2,3],[4,5,6]]
print(my_list)
print(type(my_list))

1.列表的定义语法
[元素1,元素2,元素3,…]

2.什么是元素?
数据容器内的每一份数据，都称之为元素

3.元素的类型有限制吗?
元素的数据类型没有任何限制，甚至元素也可以是列表这样就定义了
嵌套列表

下标索引

# # 通过下表索引取出对应位置的数据
my_list = ["Tom","Lily","Rose"]
print(my_list[0])
print(my_list[1])
print(my_list[2])
# # 通过下表索引取出数据倒叙取出
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

# 取出嵌套列表元素
my_list = [[1,2,3],[4,5,6]]
print(my_list[0][0])

1.列表的下标索引是什么?
列表的每一个元素，都有编号称之为下标索引

从前向后的方向，编号从0开始递增
从后向前的方向，编号从-1开始递减

2.如何通过下标索引取出对应位置的元素呢?

列表[下标]，即可取出

3.下标索引的注意事项:

要注意下标索引的取值范围，超出范围无法取出元素，并且会报错

列表的常用操作（方法）
回忆:函数是一个封装的代码单元，可以提供特定功能

在Python中，如果将函数定义为class(类)的成员，那么函数会称之为:方法

def add(x,y): # 函数
	return x + y
	
class Student: # 方法
	def add(self,x,y)
	return x + y

方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同

# 函数的使用
num = add(1,2)
# 方法的使用
student = student()
num = studeng.add(1,2)

• 查找某元素的下表

  功能:查找指定元素在列表的下标，如果找不到，报错ValueError

  语法：列表.index(元素)

  index就是列表对象(变量)内置的方法(函数)

mylist =  [1, "hello", True, 3.14, None]

#1.1查找某元素在列表内的下标索引
 index = mylist.index("hello")
 print(f"hello在列表中的下标索引值是：{index}")

1.2如果被查找的元素不存在，会报错

• 修改特定下标索引的值

  mylist[0] = 114514
  print(f"列表被修改后元素值,结果是{mylist}")
  

  

• 在指定下标位置插入新元素

  mylist =  [1, "hello", True, 3.14, None]
  mylist.insert(2,"good")
  print(f"列表被插入后元素值,结果是{mylist}")
  

​

• 在列表的尾部追加、单个、新元素

  mylist =  [1, "hello", True, 3.14, None]
  mylist.append("插入到尾部")
  print(f"列表被插入尾部元素值,结果是{mylist}")
  

  

• 在列表的尾部追加``一批`、新元素

• mylist2 = [1,2,3]
  mylist.extend(mylist2)
  print(f"列表追加一个新的列表后,结果是{mylist}")
  

• .删除指定下标索引的元素(2种方式)

mylist = ["Alice", "Bob", "Charlie", "David", "Eve"]

6.1方式1:del 列表[下标]

mylist = ["Alice", "Bob", "Charlie", "David", "Eve"]

del mylist[2]
print(f"列表删除元素后结果是:{mylist}")

6.2方式2:列表.pop(下标)

mylist = ["Alice", "Bob", "Charlie", "David", "Eve"]
element = mylist.pop(1)
print(f"通过pop方法取出元素,后列表内容:{mylist},取出的元素是:{element}")

7.删除某元素在列表中的第一个匹配项

mylist = ["Alice", "Bob", "Charlie", "David", "Eve"]
mylist.remove("David")
print(f"通过remove方法移除元素后，列表结果是：{mylist}")

8.清空列表

mylist = ["Alice", "Bob", "Charlie", "David", "Eve"]
mylist.clear()
print(f"列表被清空了，结果是{mylist}")

9.统计列表内某元素的数量

mylist = ["Alice", "Bob", "Charlie", "David", "Eve", "Bob"]
count = mylist.count("Bob")
print(f"列表中Bob数量是，结果是{count}")

10.统计列表内某元素的数量

mylist = ["Alice", "Bob", "Charlie", "David", "Eve"]
count = len(mylist)
print(f"列表元素数量总共有{count}")

经过上述对列表的学习，可以总结出列表有如下特点:

• 可以容纳多个元素(上限为2**63-1、9223372036854775807个)可以容纳不同类型的元素(混装
• 数据是有序存储的(有下标序号)
• 允许重复数据存在
• 可以修改(增加或删除元素等

list (列表)遍历

列表的遍历-while循环
既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。
将容器内的元素依次取出进行处理的行为，称之为:遍历、迭代。

def list_while_func():
    mylist = ["Alice", "Bob", "Charlie", "David", "Eve"]
    index = 0
    while index < len(mylist):
        element = mylist[index]
        print(f"列表元素：{element}")
        index += 1

def list_for_func():
    mylist =[1,2,3,4,5]
    for element in mylist:
        print(f"列表元素：{element}")

list_while_func()
list_for_func()

while循环和for循环，都是循环语句，但细节不同在循环控制上:

• ·while循环可以自定循环条件，并自行控制
• for循环不可以自定循环条件，只可以一个个从容器内取出数据在无限循环上:

while循环可以通过条件控制做到无限循环for循环理论上不可以，因为被遍历的容器容量不是无限的在使用场景上:

• while循环适用于任何想要循环的场景
• for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

案例练习取出列表内的偶数

def for_in():
    mylist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    new_num = []
    for element in mylist:
        if element % 2 == 0:
            new_num.append(element)

    print(f"通过for循环从列表:{mylist}取出偶数:{new_num}")
    
for_in()

def while_in():
    mylist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    new_num = []
    index = 0
    while index < len(mylist):
        element = mylist[index]
        index += 1
        if element %2 == 0:
            new_num.append(element)
    print(f"通过while循环从列表:{mylist}取出偶数:{new_num}")

while_in()

数据容器：tuple(元组)

#定义元组

t1 =(1,"hello",True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)},内容是{t1}")
print(f"t2的类型是：{type(t2)},内容是{t2}")
print(f"t3的类型是：{type(t3)},内容是{t3}")

#定义单个元素的元素

t4 =("hello",) # 当个定义需要在后面加上,号
print(f"t4的类型是：{type(t4)},内容是{t4}")

#元组的嵌套

t5 = ((1,"hello",True),(2,"world",False))
print(f"t5的类型是：{type(t5)},内容是{t5}")

用下标索引取出元组

t5 = ((1,"hello",True),(2,"world",False))
num = t5[0][1]
print(f"用下标索引取出的元组是{num}")

#元组的操作:index查找方法

t6 = ("Alice", "Bob", "Charlie", "David", "Eve")
index = t6.index("Bob")
print(f"Bob在元组里面算下标为：{index}个")

#元组的操作:count统计方法

t7 = ("Alice", "Bob", "Charlie", "David", "Eve", "Bob", "Bob")
num = t7.count("Bob")
print(f"Bob在元组数量里面有{num}个")

#元组的操作:len函数统计元组元素数量

t8 = ("Alice", "Bob", "Charlie", "David", "Eve", "Bob", "Bob")
num = len(t8)
print(f"t8元组的长度为{num}")

#元组的遍历:while

t9 = ("Alice", "Bob", "Charlie", "David", "Eve", "Bob", "Bob")
index = 0
while index < len(t9):
    print(f"t9的元素有{t9[index]}")
    index+=1

#元组的遍历:for

t9 = ("Alice", "Bob", "Charlie", "David", "Eve", "Bob", "Bob")
for element in t9:
    print(f"t9的元素有{element}")

#元组无法修改但是能修改元组里面的list

t10 = (1,2,["hello","world"])
t10[2][0] = "你好"
t10[2][1] = "世界"
print(f"经过修改后t10的元素是")

元组的特点

经过上述对元组的学习，可以总结出列表有如下特点:

• 可以容纳多个数据
• 可以容纳不同类型的数据(混装)
• 数据是有序存储的(下标索引)
• 允许重复数据存在
• 不可以修改(增加或删除元素等)
• 支持for循环
• 多数特性和list一致，不同点在于不可修改的特性，

t1 = ("周杰伦",11,["football","music"])
# 查询年龄所在的下标位置
# index = t1.index(11)
# print(f"查询年龄所在的下标位置为:{index}")
#
# #查询学生姓名
# name = t1[0]
# print(f"学生姓名：{name}")

#删除学生爱好football
# del t1[2][0]
# print(t1)

#增加兴趣爱好coding 到list内
t1[2].append("conding")
print(t1)

数据容器:str(字符串)

通过下标索引取值

my_str ="itheima and itcast"
#通过下标索引取值
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}取下标为2的元素,值是{value}取下标-16元素值是:{value2}")

index方法

my_str ="itheima and itcast"
value =my_str.index("and")
print(f"在字符串{my_str}中找and，下标为{value}")

replace方法

my_str ="itheima and itcast"
new_my_str = my_str.replace("it","程序")
print(f"将字符串{my_str}，进行替换后得到:{new_my_str}")

split方法

my_str = "hello python itheima itcast"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到:{my_str_list}，类型是:{type(my_str_list)}")

strip方法

my_str = "  hello python itheima itcast  "
my_str_list = my_str.strip()
print(f"字符串{my_str}被strip后，结果:{new_my_str}")

my_str = "12hello python itheima itcast21"
my_str_list = my_str.strip("12")
print(f"字符串{my_str}被strip("12)后，结果:{new_my_str}")

#统计字符串中某字符申的出现次数

my_str = "itheima and itcast"
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是:{count}")#统计字符串的长度，len()

统计字符申的长度

my_str = "itheima and itcast"
num = len(my_str)
print(f"字符串{my_str}的长度是:{num}")

作为数据容器，字符串有如下特点:

• 只可以存储字符串
• 长度任意取决于内存大小)
• 支持下标索引
• 允许重复字符串存在不可以修改(增加或删除元素等)
• 支持for循环

mystr = "itheima itcast boxuegu"
#统计字符串里面有多少个it
count = mystr.count("it")
print(f"统计字符串里面有{count}个")
#将字符串里面的空格替换为字符“|”
new_str = mystr.replace(" ","|")
print(f"将空格，进行替换后得到:{new_str}")
#并按照“|”进行字符串分割得到列表

my_str_list = new_str.split("|")
print(f"将|进行分割后得到:{my_str_list}")

数据容器的切片

#对list进行切片，从1开始，4结束，步长1

my_list = [0,1,2,3,4,5,6]
result1 = my_list[1:4] #默认步长是1可以省略不写
print(f"结果是：{result1}")

#对tuple进行切片，从头开始，到最后结束，步长1

my_tuple = (1,2,3,4,5,6)
result2 = my_tuple[:] #从头到尾结束步长为1
print(f"结果是：{result2}")

#对str进行切片，从头 开始，到最后结束，步长2

my_str = "01234567"
result3 = my_str[::2]
print(f"结果是:{result3}")

#对str进行切片，从头开始，到最后结束，步长-1

my_str = "01234567"
result3 = my_str[::-1]
print(f"结果是:{result3}")

#对列表进行切片，从3开始，到1结束，步长-1

my_list = [0,1,2,3,4,5,6]
result7 = my_list[3:1:-1] 
print(f"结果是：{result7}")

#对元组进行切片，从头开始，到尾结束，步长-2

my_tuple1 = (0,1,2,3,4,5,6)
result8 = my_tuple1[::-2] 
print(f"结果是：{result8}")

1.什么是序列?

• 内容连续、有序，支持下标索引的一类数据容器

2.哪些数据容器可以视为序列?

• 列表、元组、字符串

3.序列如何做切片
序列[起始:结束:步长
起始可以省略，省略从头开始
结束可以省略，省略到尾结束
步长可以省略，省略步长为1(可以为负数，表示倒序执行)

练习案例:序列的切片实践
有字符串:"万过薪月，员序程马黑来，nohtyP学请使用学过的任何方式，得到"黑马程序员"

mystr ="月薪过万，员序程马黑来,nohtyP学"
new_str  = mystr[9:4:-1]
print(f"{new_str}")

数据容器:set(集合)

#定义集合

my_set = {"itheima","传智教育","黑马程序员","itheima","传智教育","黑马程序员"}
my_set_empty = set()
print(f"my_set的内容是{my_set},类型是{type(my_set)}")
print(f"my_set_empty的内容是{my_set_empty},类型是{type(my_set_empty)}")

#添加新元素

my_set.add("Python")
my_set.add("传智教育")
print(f"my_set添加元素后结果是:{my_set}")

#移除元素

my_set.remove("黑马程序员")
print(f"my_set移除后元素后结果是:{my_set}")

随机取出一个元素

my_set = {"itheima","传智教育","黑马程序员","itheima","传智教育","黑马程序员"}
element = my_set.pop()
print(f"集合被取出的元素是:{element},取出元素后{my_set}")

清空集合

new_element = my_set.clear()
print(f"清空集合后{new_element},类型是{type(new_element)}")

#取2个集合的差集

set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(f"取出差集的结果{set3}")
print(f"取出差集后原有的set1的内容{set1}")
print(f"取出差集后原有的set1的内容{set2}")

#消除2个集合的差集

set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)
print(f"消除差集后原有的set1的内容{set1}")
print(f"消除差集后原有的set2的内容{set2}")

#2个集合合并为1个

set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(f"合并后的结果:{set3}")
print(f"合并后set1的结果")
print(f"合并后set2的结果")

#统计集合元素数量

set1 = {1,2,2,3,4,5}
num = len(set1)
print(f"集合的元素数量有：{num}个")

集合循环

集合没有下标索引所以不支持while循环

但是支持for循环

set1={1,2,3,4,5}
for i in set1:
    print(f"集合的元素有{i}")	

经过上述对集合的学习，可以总结出集合有如下特点:

• 可以容纳多个数据
• 可以容纳不同类型的数据(混装)数据是无序存储的(不支持下标索引)
• 不允许重复数据存在
• 可以修改(增加或删除元素等)
• 支持for循环

my_list = ["黑马程序员","传智博客","黑马程序员","传智博客","itheima","itcase","itheima","itcase","best"]
my_list_empty = set()
print(f"列表内容为:{my_list}")
for i in my_list:
    my_list_empty.add(i)
print(f"{my_list_empty}")

数据容器:dict(字典、映射)

定义字典

my_dict = {"王力宏":99,"周杰伦":88,"林俊杰":77}

定义空字典

my_dict2 = {}
my_dict3 =dict()
print(f"字典1的内容是:{my_dict},类型是{type(my_dict)}")
print(f"字典1的内容是:{my_dict2 },类型是{type(my_dict2)}")
print(f"字典1的内容是:{my_dict3},类型是{type(my_dict3)}")

定义重复Key的字典

my_dict1 = {"王力宏":99,"王力宏":88,"林俊杰":77}
print(f"重复key的字典内容是:{my_dict1}")

从字典中基于Key获取Value

my_dict1 = {"王力宏":99,"周杰伦":88,"林俊杰":77}
score = my_dict1["王力宏"]
print(f"王力宏的考试分数是:{score}")

score = my_dict1["周杰伦"]
print(f"周杰伦的考试分数是:{score}")

定义嵌套字典 #从嵌套字典中获取数据

stu_score_dict = {
    "王力宏":{
        "语文":77,
        "数学":66,
        "英语":33
    },"周杰伦":{
        "语文":88,
        "数学":86,
        "英语":55
    },"林俊杰":{
        "语文":99,
        "数学":96,
        "英语":66
    }
}
print(f"学生的考试信息是:{stu_score_dict}")

socre = stu_score_dict["周杰伦"]["语文"]
print(f"周杰伦的语文分数是:{socre}")

字典

#新增元素

my_dict = {"周杰伦":99,"林俊杰":88,"张学友":77}
my_dict["张信哲"] = 66
print(f"字典经过新增元素后,结果：{my_dict}")

更新元素

my_dict["周杰伦"] = 33
print(f"字典经过更新后,结果:{my_dict}")

删除元素

score = my_dict.pop("周杰伦")
print(f"字典中被移除了一个元素,结果{my_dict},周杰伦的考试分数是:{score}")

#清空元素

my_dict.clear()
print(f"字典被清空了,内容是:{my_dict}")

#获取全部的key

my_dict = {"周杰伦":99,"林俊杰":88,"张学友":77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")

#遍历字典

# 方式1：通过获取全部的key来完成遍历
for key in keys:
    print(f"字典的key是{key}")
    print(f"字段的value是{my_dict[key]}")
    
# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict
	print(f"2字典的key是{key}")
	print(f"2字典的value是:{my_dict[key]}")

字典不支持下标索引索引没有while循环

#统计字典内的元素数量

my_dict = {"周杰伦":99,"林俊杰":88,"张学友":77}
num = len(my_dict)
print(f"元素数量为{num}")

经过上述对字典的学习，可以总结出字典有如下特点:

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是KeyValue键值对可以通过Key获取到Value，Kty不可重复(重复会覆盖
• 不支持下标索引
• 可以修改(增加或删除更新元素等)
• 支持for循环不支持while循环

my_dict ={
    "王力宏":{
        '部门':'科技部',
        '工资':3000,
        '级别':1
    },"周杰伦":{
        '部门':'市场部',
        '工资':5000,
        '级别':2
    },"林俊杰":{
        '部门':'市场部',
        '工资':7000,
        '级别':3
    },"张学友":{
        '部门':'科技部',
        '工资':4000,
        '级别':1
    },"刘德华":{
        '部门':'市场部',
        '工资':6000,
        '级别':2
    }
}

print(f"当回全员工信息如下:\n{my_dict}")
for key in my_dict:
    if  my_dict[key]["级别"] == 1:
        my_dict[key]["工资"] += 1000
print(f"全体员工级别1的员工完成升职加薪操作后，操作后:\n{my_dict}")

数据容器对比

数据容器可以从以下视角进行简单的分类:
是否支持下标索引

• 支持:列表、元组、字符串 -序列类型

• 不支持:集合、字典 -非序列类型

是否支持重复元素

• 支持:列表、元组、字符串 -序列类型

• 不支持:集合、字典 -非序列类型

是否可以修改

• 支持:列表、集合、字典
• 不支持:元组、字符串

1.基于各类数据容器的特点，它们的应用场景如下

• 列表:一批数据，可修改、可重复的存储场景
• 元组:一批数据，不可修改、可重复的存储场景
• 字符串:一串字符串的存储场景
• 一批数据集合:去重存储场景
• 字典:一批数据，可用Key检索Value的存储场景

数据容器的通用操作

数据容器的通用操作-遍历
数据容器尽管各自有各自的特点，但是它们也有通用的一些操作，
首先，在遍历上:

• 5类数据容器都支持for循环遍历
• 列表、元组、字符串支持while循环，集合、字典不支持(无法下标索引)
• 尽管遍历的形式各有不同，但是，它们都支持遍历操作，

len 元素个数

my_list = [1,2,3,4,5]
my_tuple = (1,2,3,4,5)
my_str = "abcdefg"
my_set = {1,2,3,4,5}
my_dict = {"key1":1,"key2":2,"key3":3,"key4":4,"key5":5}
#len 元素个数
print(f"列表 元素个数有：{len(my_list)}")
print(f"元组 元素个数有：{len(my_tuple)}")
print(f"字符串 元素个数有：{len(my_str)}")
print(f"集合 元素个数有：{len(my_set)}")
print(f"字典 元素个数有：{len(my_dict)}")

max最大元素

print(f"列表 的最大个数：{max(my_list)}")
print(f"元组的最大个数 ：{max(my_tuple)}")
print(f"字符串的最大个数：{max(my_str)}")
print(f"集合的最大个数：{max(my_set)}")
print(f"字典的最大个数：{max(my_dict)}")

min的最小元素

print(f"列表最小个数：{min(my_list)}")
print(f"元组列表最小个数：{min(my_tuple)}")
print(f"字符串列表最小个数：{min(my_str)}")
print(f"集合列表最小个数：{min(my_set)}")
print(f"字典列表最小个数：{min(my_dict)}")

类型转化：容器转列表

print(f"列表 转列表：{list(my_list)}")
print(f"元组  转列表：{list(my_tuple)}")
print(f"字符串  转列表：{list(my_str)}")
print(f"集合  转列表：{list(my_set)}")
print(f"字典  转列表：{list(my_dict)}")

类型转换：容器转元组

print(f"列表 转列表：{tuple(my_list)}")
print(f"元组  转列表：{tuple(my_tuple)}")
print(f"字符串  转列表：{tuple(my_str)}")
print(f"集合  转列表：{tuple(my_set)}")
print(f"字典  转列表：{tuple(my_dict)}")

类型转换：容器转字符串

print(f"列表 转字符串：{str(my_list)}")
print(f"元组  转字符串：{str(my_tuple)}")
print(f"字符串  转字符串：{str(my_str)}")
print(f"集合  转字符串：{str(my_set)}")
print(f"字典  转字符串：{str(my_dict)}")

类型转换：容器转集合

print(f"列表 转集合：{set(my_list)}")
print(f"元组  转集合：{set(my_tuple)}")
print(f"字符串  转集合：{set(my_str)}")
print(f"集合  转集合：{set(my_set)}")
print(f"字典  转集合：{set(my_dict)}")

进行容器的排序

my_list = [3,5,4,1,2]
my_tuple = (3,5,4,1,2)
my_str = "gfhdsaj"
my_set = {3,5,4,1,2}
my_dict = {"key3":1,"key1":2,"key2":3,"key5":4,"key4":5}

print(f"列表 对象的排序结果是：{sorted(my_list)}")
print(f"元组  对象的排序结果是：{sorted(my_tuple)}")
print(f"字符串  对象的排序结果是：{sorted(my_str)}")
print(f"集合  对象的排序结果是：{sorted(my_set)}")
print(f"字典  对象的排序结果是：{sorted(my_dict)}")

进行容器的逆向排序

print(f"列表 对象的排序结果是：{sorted(my_list,reverse=True)}")
print(f"元组  对象的排序结果是：{sorted(my_tuple,reverse=True)}")
print(f"字符串  对象的排序结果是：{sorted(my_str,reverse=True)}")
print(f"集合  对象的排序结果是：{sorted(my_set,reverse=True)}")
print(f"字典  对象的排序结果是：{sorted(my_dict,reverse=True)}")

字符串大小比较

#abc 比较abd
print(f"abd大于abc,结果:{'abb'>'abc'}")
# a 比较 ab
print(f"ab大于a,结果：{'ab'>'a'} ")
# a 比较 A
print(f"a大于A,结果：{'aG'>'A'} ")
# key1 比较 key2
print(f"key2大于key1,结果：{'key2'>'key1'} ")

1.字符串如何比较
从头到尾一位位进行比较，其中一位大，后面就无需比较了。
2.单个字符之间如何确定大小?
通过ASCII码表，确定字符对应的码值数字来确定大小

python进阶

函数的多返回值

def test_return():
    return 1,2,3
x,y,z = test_return()
print(x)
print(y)
print(z)

类型不受限

函数的多种传参方式

位置参数:调用函数时根据函数定义的参数位置来传递参数

def user_info(name,age,gender):
    print(f"姓名是:{name}，年龄是:{age},性别是:{gender}")

#位置参数-默认使用形式
user_info('小明',20,'男')

注意:
传递的参数和定义的参数的顺序及个数必须一致

关键字参数:函数调用时通过键=值形式传递参数

作用:可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求

def user_info(name,age,gender):
    print(f"姓名是:{name}，年龄是:{age},性别是:{gender}")
    
user_info(name='老王',age=11,gender='女')
user_info(age=10,gender='女',name='小红')
user_info('蓝蓝',gender='女',age= 12)

注意:
函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序

#缺省参数(默认值) 默认参数要写在最后面

def user_info(name,age,gender = '男'):
    print(f"姓名是:{name}，年龄是:{age},性别是:{gender}")

user_info('小天',13)
user_info('小天',13,gender='女')

不定长参数

不定长参数:不定长参数也叫可变参数、用于不确定调用的时候会传递多少个参数(不传参也可以)的场景.作用:当调用函数时不确定参数个数时，可以使用不定长参数

不定长参数的类型:
①位置传递

def user_info(*args):
    print(f"args参数的类型是:{type(args)},内容是:{args}")
user_info(1,2,3,"小明",'男孩')

注意:
传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为元组(tuple),args是元组类型，这就是位置传递

②关键字传递

def user_info(**kwargs):
    print(f"kwargs参数的类型是:{type(kwargs)},内容是:{kwargs}")
user_info(name='小明',gender='男孩',age=10)

注意:
参数是“键=值”形式的形式的情况下，所有的“键=值”都会被kwargs接受，同时会根据“键=值”组成字典

1.掌握位置参数

根据参数位置来传递参数
2.掌握关键字参数

通过“键=值”形式传递参数，可以不限参数顺序可以和位置参数混用，位置参数需在前

3.掌握缺省参数

不传递参数值时会使用默认的参数值默认值的参数必须定义在最后
4.掌握不定长参数

• 位置不定长传递以*号标记一个形式参数，以元组的形式接受参数形式参数一般命名为args
• 关键字不定长传递以**号标记一个形式参数，以字典的形式接受参数，形式参数一般命名为kwargs

函数作为参数

#定义一个函数,接受另一个函数作为传入参数
def test_func(compute):
    result = compute(1,2)
    print(f"compute参数的类型是:{type(compute)}")
    print(f"计算结果是:{result}")
#定义一个函数,准备作为参数传入另一个函数
def compute(x,y):
    return  x+y
#调用,并传入函数
test_func(compute)

1.函数本身是可以作为参数，传入另一个函数中进行使用的而非传入数

2.将函数传入的作用在于:传入计算逻辑据

匿名函数

函数的定义中

• def关键字，可以定义带有名称的函数
• lambda关键字，可以定义匿名函数(无名称)有名称的函数，可以基于名称重复使用无名称的匿名函数，只可临时使用一次，

匿名函数定义语法:

• lambda 传入参数:函数体(一行代码)
• lambda是关键字，表示定义匿名函数
• 传入参数表示匿名函数的形式参数，如:x,y表示接收2个形式参数函数体，就是函数的执行逻辑，要注意:只能写一行，无法写多行代码

#定义一个函数,接受另一个函数作为传入参数
def test_func(compute):
    result = compute(1,2)
    print(f"compute参数的类型是:{type(compute)}")
    print(f"计算结果是:{result}")
#通过lamabda 匿名函数的形式,将匿名函数作为参数传入
test_func(lambda x,y:x+y)

1.匿名函数使用lambda关键字进行定义

2.定义语法:

• lambda 传入参数:所数体(一行代码)

3.注意事项:

• 匿名函数用于临时构建一个函数，只用一次的场景
• 匿名函数的定义中，函数体只能写一行代码，如果函数体要写多行代码，不可用lambda匿名函数，应使用def定义带名函数

python文件操作

文件编码的概念

1.什么是编码?

编码就是一种规则集合记录了内容和二进制间进行相互转换的逻辑，编码有许多中，我们最常用的是UTF-8编码
2.为什么需要使用编码?

计算机只认识0和1，所以需要将内容翻译成0和1才能保存在计算机中。
同时也需要编码，将计算机保存的0和1，反向翻译回可以识别的内容。

文件读取操作

open()打开函数

在Python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件，语法如下

open(name,mode,encoding)

name：是要打开的目标文件名的字符串(可以包含文件所在的具体路径)。

mode：设置打开文件的模式(访问模式):只读、写入、追加等。

encoding:编码格式(推荐使用UTF-8)

#打开文件
f = open("D:/测试.txt","r",encoding="UTF-8")
print(type(f))

read()读取文件

#打开文件
f = open("D:/测试.txt","r",encoding="UTF-8")
print(type(f))
#读取文件 - read()
print(f"读取10个字节的结果:{f.read(10)}")
print(f"read方法:{f.read()}")

在程序里面多次调用read下一次read会在上一次read的结尾处接着读取的

readlines()读取文件

读取文件的全部行，封装到列表中

lines =f.readlines() 
print(f"lines对象的类型:{type(lines)}")
print(f"lines对象的内容是:{lines}") 

readline()读取文件

每次只读取一行

line1 = f.readline()
line2 = f.readline()
line3 = f.readline()
print(f"第一行数据是:{line1}")
print(f"第二行数据是:{line2}")
print(f"第三行数据是:{line3}")

for循环读取文件行

for line in f:
    print(f"每一行的数据是:{line}")

#文件关闭

f.close()
time.sleep(50000)

最后通过close，关闭文件对象，也就是关闭对文件的占用。如果不调用close,同时程序没有停止运行，那么这个文件将一直被Python程序占用

with open 语法操作文件

with open("D:/测试.txt","r",encoding="UTF-8") as f:
    for line in f:
        print(f"每一行数据是{line}")
time.sleep(500000)

当文件操作完之后会自动关闭

1.操作文件需要通过ppen函数打开文件得到文件对象
2.文件对象有如下读取方法

• read()
• readline()
• readlines()
• for linein 文件对象

3.文件读取完成后，要使用文件对象.close()方法关闭
文件对象，否则文件会被一直占用

# 1. count 移到循环外面，避免重置
count = 0
# 2. 用 with 自动关闭文件，更规范
with open("D://测试.txt", "r", encoding="UTF-8") as f:
    for line in f:
        line = line.strip() #去除开头和结尾的空格以及换行符
        words = line.split(" ")
        for word in words:
            if word == "itheima":
                count += 1 #如果单词是itheima 进行数量的累加加1

print(f"itheima（单独一行）出现的次数是：{count}")
f.close()

文件的写入

案例演示:

#1.打开文件
f= open('python.txt','w')

2.文件写入
f.write(hello world!)

3.内容刷新
f.flush()

注意:
直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区当调用flush的时候，内容会真正写入文件
这样做是避免频繁的操作硬盘，导致效率下降(攒一堆，一次性写磁盘)

#打开文件，不存在的文件
f = open("D://test.txt","w",encoding="UTF-8")
# write写入
f.write("Hello World!!!")
#flush刷新
f.flush() 
#close关闭
f.close() #close 方法,内置了flush的功能

#打开一个存在的文件#write写入、flush刷新
f = open("D://test.txt","w",encoding="UTF-8")
f.write("你好世界!!!")
#close关闭
f.close()

当文件存在的时候如果文件里面有内容，会将文件里面的内容清理了之后再写入

1.写入文件使用open函数的模式进行写入

2.写入的方法有:

• wirte()，写入内容
• flush()，刷新内容到硬盘中

3.注意事项

• w模式，文件不存在，会创建新文件
• w模式，文件存在，会清空原有内容
• close()方法，带有flush()方法的功能

文件的追加

#打开文件，不存在的文件
f = open("D://test.txt","a",encoding="UTF-8")
# write写入
f.write("生活不会因为你的年龄而放弃对你的毒打!!!")
#flush刷新
f.flush()
#close关闭
f.close()

#打开一个存在的文件#write写入、flush刷新
f = open("D://test.txt","a",encoding="UTF-8")
f.write("你好世界!!!")
#close关闭
f.close()

1.追加写入文件使用open函数的"a模式进行写入
2.追加写入的方法有(和w模式一致)

• wirte()，写入内容
• flush()，刷新内容到硬盘中

3.注意事项 :

• a模式，文件不存在，会创建新文件
• a模式，文件存在，会在原有内容后面继续写入
• 可以使用”\n”来写出换行符

文件操作的综合案例

了解异常

1.什么是异常
异常就是程序运行的过程中出现了错误
2.bug是什么意思
bug就是指异常的意思，因为历史因为小虫子导致计算机失灵的案例，所以延续至今，bug就代表软件出现错
误。

异常捕获

基本捕获语法

try:
    f = open("D://abc.txt","r",encoding="UTF-8")
except:
    print("出现异常了因为不存在，我将open模式改为w模式去打开")
    f = open("D://abc.txt", "w", encoding="UTF-8")

捕获指定异常

try:
    print(name)
except NameError as e:
    print("出现了变量未定义的异常")
    print(e)

捕获多个指定的异常

try:
    1 / 0
except (NameError ,ZeroDivisionError ) as e:
    print("出现了变量未定义或者 除以0的异常错误")

未正确设置捕获异常类型,将无法捕获异常

捕获所以异常

try:
    f = open("D://123.txt")
except Exception as e:
    print("出现异常了")

异常else

try:
    print("hello")
except Exception as e:
    print("出现异常了")
else:
    print("没异常")

异常finally

try:
    print("hello")
except Exception as e:
    print("出现异常了")
else:
    print("没异常")
    
finally:
	print("我是finally，有没有异常我都要执行")
	f.close()

异常的传递

def func1():
    print("func1开始执行")
    num = 1/0
    print("func1 结束执行")
def func2():
    print("func2开始执行")
    func1()
    print("func2结束执行")
def main():
    try:
        func2()
    except Exception as  e:
        print(f"出现异常了,异常信息是:{e}")
main()

异常的传递
异常是具有传递性的

当函数func01中发生异常，并且没有捕获处理这个异常的时候，异常会传递到函数func02，当func02也没有捕获处理这个异常的时候main函数会捕获这个异常，这就是异常的传递性

提示:
当所有函数都没有捕获异常的时候，程序就会报错

python模块

什么是模块

Python 模块(Module)，是一个
Python 文件
以py 结尾.
模块能定义函数，类和变量
模块里也能包含可执行的代码

模块的作用:

python中有很多各种不同的模块，每一个模块都可以帮助我模块的作用:们快速的实现一些功能，比如实现和时间相关的功能就可以使用time模块我们可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用进而实现各种不同的功能.

比如实现和时间相关的功能就可以使用time模块我们可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用进而实现各种不同的功能.

使用import导入time模块使用sleep功能(函数)

import time #导入python内置的time模块 
print("你好") 
time.sleep(5) # 通过,就可以使用模块内部的全部功能(类，函数,变量)
print("hello")

使用from导入time的sleep功能(函数)

from time import sleep
print("你好")
sleep(5)
print("world")

使用* 导入time模块的全部功能

from time import *
print("你好")
sleep(5)
print("我好")

使用as给特定功能加上别名

import time as t
print("你好")
t.sleep(5)
print("我好")

给time模块的sleep的名字改为sl

from time import sleep as sl
print("你好")
sl(5)
print("我好")

python自定义模块

在my_module1.py下面创建函数

def test(a,b):
    print(a+b)

导入自定义模块使用

#第一种
import my_module1 
my_module1.test(1,2)

#第二种
from my_module1 import test
test(1,2)

导入不同模块的同名功能

from my_module1 import test
from my_module2 import test
test(1,2)

my_module1没被使用

__main__变量

from my_module1 import test
test (1,2)

def test(a,b):
    print(a+b)

if __name__ == '__main__':
    test(1,2)

all变量

my_module1.py

__all__= ['test_a']

def test_a(a,b):
    print(a+b)

def test_b(a,b):
    print(a-b)

from my_module1 import *
test_a(1,2)
test_b(2,1)

只能使用__all__只能允许使用test_a不能使用test_b

1.如何自定义模块并导入?

• 在Python代码文件中正常写代码即可，通过import、from关键字和导入Python内置模块一样导入即可使用，

2.main_变量的功能是?

• if main==main”表示，只有当程序是直接执行的才会进入if内部，如果是被导入的，则if无法进入

3.注意事项

• 同名的功能，如果都被导入，那么后导入的会覆盖先导不同模块，
  入的
• all 变量可以控制import*的时候哪些功能可以被导入

Python包

创建一个包

# 导入自定义的包中的模块，并使用
#第一种方式导入python包的方式
import my_package.my_module1
import my_package.my_module2

my_package.my_module1.info_print1()
my_package.my_module2.info_print2()

#第二种
from my_package import my_module1
from my_package import my_module2
my_module1.info_print1()
my_module2.info_print2()

#第三种
from my_package.my_module1 import info_print1
from my_package.my_module2 import info_print2
info_print1()
info_print2()

通过__all__变量 控制import *

from my_package import *
my_module1.info_print1()
my_module1.info_print2()

1.什么是Python的包?

-个文件夹，里面可以存放许多Python的模块(代码文件)，通包就是一过包，在逻辑上将一批模块归为一类，方便使用。

2.init.py文件的作用?

创建包会默认自动创建的文件，通过这个文件来表示一个文件夹是Python的包，而非普通的文件夹。

3._all 变量的作用?

同模块中学习到的是一个作用，控制import*能够导入的内容

python第三方包

1.什么是第三方包?有什么作用?

第三方包就是非Python官方内置的包，可以安装它们扩展功能，提高发效率。

2.如何安装?
在命令提示符内:

• pip install 包名称
• pip install -i
  https://pypi.tuna.tsinghua.edu.cn/simple包名称
• 在PyCharm中安装

python异常、模块、包：综合案例

str_util.py

def str_reverse(s):
    rev = s[::-1]
    print(f"字符串反转后的结果是{rev}")


def substr(s, x, y):
    return s[x:y]


if __name__ == '__main__':
    str_reverse("114514")

file_util.py

def print_file_info(file_name):
    f = None
    try:
        f = open(file_name, "r", encoding="UTF-8")
        for i in f:
            print(i)
    except Exception as e:
        print(f"捕获到异常{e}")
    finally:
        # if f:
        f.close()

def append_to_file(file_name,data):
    f = open(file_name,"w",encoding="UTF-8")
    f.write(data)
    f.flush()
    f.close()
    print("文件写入完成")

if __name__ == '__main__':
    # print_file_info("D://测试.txt")
    append_to_file("D://测试.txt","输入一段中文")