Python的基础学习

测试道路探索中

已于 2024-10-22 09:08:21 修改

阅读量1.5k

点赞数 41

文章标签： python 学习 java

于 2024-04-28 17:32:17 首次发布

本文链接：https://blog.csdn.net/wahahayou123456/article/details/138284641

版权

第一章

安装以及简单的运用pyCharm

1.编写第一个程序：打出你好世界！！

2.常见会出现的问题

（1）命令提示符的打开：win+R同时按，再输入cmd

（2）命令提示符内，输入python出现‘python’不是内部命令或外命令，也不是可运行的程序或批处理文件

原因：在安装python时没有勾选：add python 3.10 to PATH的选项

(3))命令提示符内出现：无法初始化设备PRN

(4)执行出现SyntaxError:invalid character' "'(U+201C)

3.python解释器：翻译代码，交给计算机运行

解释器的位置：Python的安装目录中一个叫Python.exe的文件

第二章

一、Python的基础知识

字面量：在代码中，被写下来的固定值

常见的6种（数据）类型

1.字符串：

又称文本，由任意数量的字符如中文、英文、各类符号、数字等组成。

在Python中，字符串需要用英文的双引号（""）包起来，然后可以得出用引号包起来的都是字符串。如："黑马程序员"

2.注释：

（1）单行注释：#开头，#右边的所有文字当做说明，不参与代码的运行，起相应代码的解释作用，建议#与注释之间间隔一个空格

（2）多行注释：''' '''三个单引号或""" """三个双引号

3.变量：

在程序运行时，能储存计算结果或能表示值的抽象概念（就是在程序运行时，记录数据用的）

变量名=变量值

# 定义一个变量，用来记录钱包余额
money=50  
# 通过print语句输出变量记录
print("钱包还有：",money)
# 买了一个冰淇淋，花费10元
money = money-10
print("钱包还剩：",money)

4.查看变量存储的数据类型（type()）

name = "黑马程序员"
print(type(name))
print(type(666))
print(type(12.14))

在Python中变量没有类型，变量存储的数据才有类型

5.数据类型的转换

这三个语句都是带有结果的（返回值），可以用print直接输出，也可用变量存储结果值

# 将数字转换为字符串,万物皆可转字符串
num_str = str(111)
print(type(num_str))
# 将字符串转换为数字，字符串的内容需要是数字次啊能转换
num = int("111")
print(type(num))
# 浮点数转换成整数
float_int = int(12.45)
print(type(float_int))

6.标识符：在用户编程时使用的命名名字

标识符命名中，只允许出现：英文、中文、数字、下划线（_）这四类元素

不推荐使用中文，数字不可以开头，可以区分大小写

不可以使用的关键字：同样大小写敏感Type≠type

标识符的规范：见名知意、下划线命名（多个单词用下划线隔开）、英文字符建议全小写

7.运算符

print("1+1 = ",1+1)
print("1-1 = ",1-1)
print("1*1 = ",1*1)
print("1/1 = ",1/1)

num=1
num +=1
print("num +=1",num)
num -=1
print("num -=1",num)
num *=1
print("num *=1",num)
num /=1
print("num /=1",num)
num %=1
print("num %=1",num)
num **=1
print("num **=1",num)
num //=1
print("num //=1",num)#取整除

二、字符串的相关知识

（1）定义方法：

# 单引号定义法
name = '黑马程序员'
print(type(name))
# 双引号定义法
name = "黑马程序员"
print(type(name))
# 三组引号命名法
name = """黑马程序员"""
print(type(name))
# 在字符串内包含双引号
name = '"黑马程序员"'
print(name)
#在字符串内包含单引号
name = "'黑马程序员'"
print(name)
# 使用转译字符“\”解除引号的效用
name = "\"黑马程序员\""
print(name)
name = '\'黑马程序员\''
print(name)

（2）字符串的拼接

# 字符串字面量和字符串变量的拼接,“+”只能用于字符串拼接
name = "黑马程序员"
address = "建材城"
print("我是：" +name+"，住宅在："+address+"")

（3）字符串格式化

# 1.通过占位符的形式，完成数字和字符串的拼接
class_num = 57
avg_salary = 1688
message = "Python大数据学科，北京%s期，毕业条件：%s"%(class_num,avg_salary)
print(message)

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

# 2.f"{占位}"
name = "传智博客"
set_up_year = 2006
stock_price = 19.99
# f:format
print(f"我是{name},成立于：{set_up_year}年，我今天的股价是：{stock_price}")
#表达式（具有明确结果的代码语句）进行字符串格式化
print("1 * 1 的结果是： %d" %(1 * 1))
print(f"1 * 2 的结果是： {1 * 2}")
print("字符串在Python中的类型名是：%s" %type("字符串"))

三、数据输入（input语句）

（1）input语句的定义

# 1.
print("请告诉我你是谁？")
name = input()
print("Get!!!你是：%s" % name)
# 2.
name = input("请告诉我你是谁？")
print("Get!!!你是：%s" % name)

# 输入数字类型,不管你是什么类型，input默认接受的类型都是字符串，若想转换成其他类型可进行数据类型的转换
num = input("请告诉我你的银行卡密码：")
# 数据类型的转换
num = int(num)
print("你的银行卡密码是：",type(num))

第三章

一、布尔类型和比较运算符

布尔的定义：表达现实生活中的逻辑，即真和假，True表示真（本质上是数字1），False表示假（本质上是数字0）

定义变量存储布尔类型数据：变量名称 = 布尔类型字面量。

result = 10 > 5
print(f"10 > 5的结果是：{result},类型是：{type(resul)}")

比较运算符

# 定义自变量存储布尔类型的数据
bool_1 = True
bool_2 = False
print(f"bool_1变量的内容是：{bool_1}，类型是：{type(bool_1)}")
print(f"bool_2变量的内容是：{bool_2}，类型是：{type(bool_2)}")
# 比较运算符的使用
# ==
num1 = 10
num2 = 10
print(f"10==10的结果是：{num1 == num2}")
# !=
num1 = 10
num2 = 15
print(f"10!=15的结果是：{num1 != num2}")

name1 = "hero"
name2 = "name"
print(f"hero!=name的结果是：{name1 != name2}")
# >.<.>=,<=
num1 = 10
num2 = 5
print(f"10>5的结果是：{num1 > num2}")
print(f"10<5的结果是：{num1 < num2}")

num1 = 10
num2 = 10
print(f"10>=5的结果是：{num1 >= num2}")
print(f"10<=5的结果是：{num1 <= num2}")

二、if语句的基本格式

if 要判断的条件：

条件成立时，要做的事情

# 定义变量
age = 18
if age >= 18 :
    print("已经成年啦")
print("时间过得真快")

# 编写输入年龄判断是否成年
# 1.定义变量，并输入
age = input("请输入你的年龄")
# 2.因为input默认输出时为字符串类型，需要转化为数字
age = type(age)
# 3.判断是否成年
if age>=18:
    print("您已成年，需要支付10元门票")
print("祝您玩得愉快")

三、if else语句、if elif else语句

（一）if else语句书写的方法：

age = type(input("请输入你的年龄"))
if age>=18:
    print("您已成年，需要支付10元门票")
else:
    print("您未成年，可以免费游玩")
print("祝您玩得愉快")

#else，不需要判断条件，前面也不需要四个空格作为缩进

（二）if elif else语句书写的方法：

# 定义一个数字
num = 3
# 通过判断获取猜想的数字，通过if和elif的组合进行猜想比较
if int(input("猜想一个数字："))==num:
    print("恭喜第一次就才对了")
elif int(input("再猜想一个数字："))==num:
    print("猜对了")
elif int(input("猜错了，再猜一次："))==num:
    print("恭喜你，在最后一次机会中猜对了")
else:
    print("对不起，猜数字次数已经用完了，很遗憾都猜错了！")

四、判断语句的嵌套

'''只有满足第一个if后才能执行第二个if。嵌套的关键点：在于空格缩进
                              通过缩进，来决定语句的层次关系
if 条件1:
    满足条件去，做的事情1
    满足条件去，做的事情1
    if 条件2:
        满足条件去，做的事情1
        满足条件去，做的事情1
'''
print("欢迎来到黑马动物园")
if int(input("请输入你的身高"))>120:
    print("身高超出限制，不能免费")
    print("但是，如果vip超过3，可以免费")

    if int(input("请输入你的vip等级"))>=3:
        print("恭喜你，vip级别达标，可以免费游玩")
     else:
        print("对不起，vip等级不够，需要付费")
else:
    print("欢迎小朋友免费游玩")


age = 20
year = 3
if age>=18:
    print("你是成年人")
    if age < 30:
        print("年龄达标")
        if year > 2:
            print("恭喜年龄和入职时间都达标，可以领取礼物")
        elif level > 3:
            print("恭喜你年龄和级别达标，可以领取礼物")
        else:
            print("对不起，只有年龄达标不能领取礼物")

    else:
        print("年龄超出，不能领取")

else:
    print("年龄太小，不能领取")

# 1.构件一个随机数字
import random
num = random.randint(1,10)

guess_num = int(input("请输入一个数字"))

# 2.通过判断语句进行数字判断
if guess_num == num:
    print("猜对了")
else:
    if guess_num >num:
        print("数字猜大了")
    else:
        print("数字猜小了")

    guess_num = int(input("请第二次输入一个数字"))

    if guess_num == num:
        print("恭喜你第二次猜对了")
    else:
        if guess_num > num:
            print("数字猜大啦")
        else:
            print("数字猜小啦")

        guess_num = int(input("请第三次输入一个数字"))

        if guess_num == num:
            print("恭喜你第三次猜对了")
        else:
            print("机会用完啦，真遗憾没有猜中")

第四章 Python循环语句的学习

一、while循环的基础语法

'''只要条件满足，会无限循环执行
while 条件：
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
'''
i = 0
while i<100:
    print("我要过四级")
    i +=1

i = 0
sum = 0
while i<100:
    sum +=i
    i+=1
print(f"1-100的累计和是：{sum}")
# 案例
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循环的嵌套运用

# 记单词100天，直到考过四级，记单词十每天需要记20个后才开始玩
# 定义 i 为天数，j 每天为记单词的个数

i = 0 
j = 0 
while i<=100:
    print(f"今天是记单词的第{i}天，继续记单词")

    #内循环
    while j <=20:
        print(f"今天记的第{j}个单词")
        j += 1
    print(f"我记完了{j-1}个单词")
    i += 1
print(f"坚持的第{i-1}天，四级成功过关")

若想print输出的语句不换行，可以：print("语句",end='')

\t：制表符，可用于表示多行对齐

# 打印九九乘法表
i = 1
while i<=9:
    j = 1
    while j<=i:
        print(f"{j}*{i}={j*i}\t",end='')
        j += 1
    i +=1
    print()

三、for循环的基础语法

1. for循环

for 临时变量 in 待处理数据集：

循环满足条件时执行的代码

# for循环就是将字符串的内容依次输出，所以for循环也叫做遍历循环
name = "itheima"
for x in name:
    # 将name的内容，挨个取出赋予x临时变量
    # 就可以在循环体内对x进行处理
    print(x)

无法定义循环条件，只能被动去除数据处理

要注意，循环内的语句，需要有空格缩进

name = "itheima is a brand of itcast"
# 定义一个变量统计a的个数
i=0
for x in name:
    if x == "a":
        i+=1
print(f"被统计的字符串中有{i}个a")

2. range语句

（1）range(num)获取一个从0开始的数字序列(不含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（默认为1）为准：

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

# 1到100（不含100本身）范围内有多少个偶数
i = 0
for x in range(1,100):
    if x%2==0:
        i += 1
print(f"一共有{i}个偶数")

3.for循环的临时变量

作用域：循环内

这种限定是规范的限定，而是非强制性的限定，不遵守也能正常运行，但是不建议，如果需要访问临时变量，可以预先在循环外去定义它

四、for循环的嵌套应用

# 编写每天都记单词，直到记完为止；每次记单词的流程是记20个单词然后休息
i = 0
for i in range(1,101):
    print(f"今天是记单词的第{i}天，加油，继续坚持")
    #为了记完单词，每天需要记20个
    for j in range(1,21):
        print(f"这是记的第{j}个单词")
    print("今天的单词记完了，可以休息了")

print(f"第{i}天后，3601个单词全部记完啦！")



# 打印九九乘法表
for i in range(1,10):
    for j in range(1,i+1):
        print(f"{j}*{i} = {j *i}\t",end=' ')
        j+=1
    i+=1
    print()

五、循环中断：break和continue

1.continue循环

上面的示例只执行语句1，2，4，不执行语句3

continue只中断所在语句的循环

2.break循环

遇到break后直接跳出全部循环，执行循环以外的语句

# break跳出循环
for x in range(1,6):
    print("语句1")
    for y in range(1,5):
        print("语句2")
        break
        print("语句3")
    print("语句4")
# 只执行语句1，2，4循环



# 发工资案例
import random
i = 1
money = 10000
for i in range(1,21):
    num = random.randint(1, 10)
    if num < 5:
        print(f"你好员工{i},你的绩效为{num},低于5，不发工资,下一位")
        continue
    if money >=1000:
        money -=1000
        print(f"你好员工{i},你的绩效为{num}，工资发放1000元，公司还剩{money}元")
    else:
        print(f"你好员工{i},公司还剩{money}元,工资不足，下月发放")

第五章函数

认识函数

1.函数的定义：

函数：组织好的，可以重复使用的，用来实现特定功能的代码段

'''参数和返回值不需要时可以省略
def 函数名（传入参数）:
    函数体
    return 返回值
'''
def say_hi():
    print("你好啊")
# 调用函数
say_hi()

函数的传入参数：

# 运用函数完成加法
# 在以下代码中先执行add(5,6)，再重新按照顺序执行，也就是说先执行被调用的函数
def add(x,y):
    result = x+y
    print(f"{x}+{y}的计算结果为：{result}")
add(5,6)

 def chushi(x):
    print("请出示你的健康码。体温测量中")
    if x <= 37.5:
        print(f"你的体温为{x},不需要隔离")
    else:
        print(f"你的体温为{x},需要隔离")
chushi(36)

2.函数的返回值：

def check(m,n):
    result = m + n
    return result

i = check(5,8)
print(i)
# 当在函数中执行到return语句时，它会默认函数执行完毕，就不再执行后面的语句，所以在编写代码的时候记得将return放在函数的最后

3. None类型：

# 无return语句的函数返回值
def say_hi():
    print("你好呀！")
    
result = say_hi()
print(f"无返回值函数，返回的内容是：{result}")
print(f"无返回值函数，返回的内容类型是：{type=(result)}")
#主动返回none的函数
def say_hi2():
    print("你好呀！")
    return None

result = say_hi2()
print(f"无返回值函数，返回的内容是：{result}")
print(f"无返回值函数，返回的内容类型是：{type=(result)}")
#None用于if判断
def chec_age(age):
    if age > 18:
        return "SUCCESS"
    else:
        return None
result = chec_age(16)
if not result:
    # 进入if表示result是None值，也就是False
    print("未成年，不可进入")
    
#None永贵声明无初始内容的变量
name = None

4.函数的说明文档

# 定义函数，进行文档说明
def add(x,y):
    """
    add函数可以接受两数相加的功能（对函数进行总体解释）
    :param x:形参x表示相加的其中一个数字
    :param y:形参y表示相加的另一个数字
    :return:表示两数相加的结果
    """
    result = x + y
    print(f"两数相加的结果是：{result}")
    return result

add(5,6)# 接触可以出现一个方框进行解析

5.函数的嵌套调用

定义：一个函数的里面又调用了另外的函数

在函数a中调用了另外的一个函数b，那么先把函数b中的任务都执行完之后才会回到上次函数a执行的位置

6.变量的作用域

定义：变量的作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用）

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

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

# 局部变量的演示
def testA():
    
    #定义局部变量
    num = 100
    print(num)
    
testA()  # 输出100
print(num) # 报错：name 'num' is not defined
# 变量a是定义在·testA·函数内部的变量，在函数外部访问则立即报错
# 局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量。（出了函数体局部变量就不能使用）

全局变量：在函数体内、外部都能生效的变量

# 定义全局变量
num = 100
def testB():
    print(num) # 访问全局变量num，并打印变量num存储的数据
    
def testC():
    print(num) # 访问全局变量num，并打印变量num存储的数据
    
testB() # 100
testC() # 100

global关键字

作用：让函数内部定义的变量变为全局变量

num = 100
def A():
    print(num)
    
def C():
    global num # 设置内部定义的变量为全局变量
    num = 200 # 局部变量
    print(num)
    
A() # 结果为100
C() # 结果为200
print(f'全局变量num = {num}') # 结果为200
# 实战
money = 500000
name = None
# 要求输入客户姓名
name = input("请输入你的姓名：")
# 定义查询的函数
def query(show_header):
    if show_header:
      print("-----------查询余额---------------\n")
    print(f"{name}，您好！您的余额为：{money}元")
# 定义取款函数
def saving():
    global money # money在函数内部定义为全局变量
    num = int(input("请输入您的存款金额"))
    money += num
    print("--------------存款----------------\n"
          f"{name}，您好！您的存款为{num}元成功\n"
          f"{name}，您好！您的余额{money}为\n")

    # 调用query函数查询
    query(False)

# 定义取款函数
def get_money():
    global money
    num = int(input("请输入您的取款金额"))
    money -= num
    print("--------------取款----------------\n"
          f"{name}，您好！您的存款为{num}元成功\n"
          f"{name}，您好！您的余额为{money}元\n")
    # 调用query函数查询
    query(False)

# 定义主菜单函数
def main():
    print("-----------------------主菜单---------------------------")
    print(f"{name}，您好！欢迎来到黑马银行ATM，请选择你需要办理的业务:")
    print("查询余额\t【请输入1】")
    print("取款\t\t【请输入2】")
    print("存款\t\t【请输入3】")
    print("退出\t\t【请输入4】")
    return input("请输入你的选择：")

# 设置无限循环，确保程序不退出
while True:
    keyboard_input = main()
    if keyboard_input == "1":
        query(True)
        continue  # 通过continue继续下一次循环，一进来就是主菜单
    elif keyboard_input == "2":
        saving()
        continue
    elif keyboard_input == "3":
        get_money()
        continue
    else:
        print("程序退出啦")
        break

第六章

一、数据容器

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

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

二、list(列表)

1.认识列表

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

my_list = ["ithenima",666,True]
print(my_list)
print(type(my_list))
# 可以正常运行，说明列表可以装任意类型的数据，最后都是列表类型

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

2.列表的下标索引：

3.嵌套列表的下标索引：

# 通过下标索引取出对应位置的数据
my_list = ["tom","list","Rose"]

# 通过下标索引取出对应位置的数据
print(my_list[0])
print(my_list[1])
print(my_list[2])

# 错误示范，取出超过下标索引的数据会报错
print(my_list[3])

# 通过下标索引取出数据（反向取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

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

4.列表的常用操作，增删改查

# 演示数据容器之间：list列表的常用操作
mylist = ["itheima","itchange","itgcxy"]
# 1.1查找某元素在列表内的下标索引
index = mylist.index("itchange")
print(f"itchange在列表中的下标索引值是：{index}")

# 1.2如果查找元素不存在，会报错
index = mylist.index("hello")
print(f"itchange在列表中的下标索引值是：{index}")

# 2.修改特定位置的元素值
mylist[0] = "快乐"
print(f"列表被修改元素值后，结果是：{mylist}")

# 3.在指定的位置添加元素
mylist.insert(1,"best")
print(f"列表插入元素后结果是：{mylist}")

# 4.在列表的尾部追加'''单个'''新元素
mylist.append("黑马程序员")
print(f"列表追加一个元素后结果是：{mylist}")

# 5.在列表的尾部追加'''一批'''元素
mylist2 = [1,2,3]
mylist.extend(mylist2)
print(f"列表追加一批元素后结果是：{mylist}")

# 6.删除制定下标索引的元素（2种方法）
mylist = ["itheima","itchange","itgcxy"]
# 6.1 放法1：del 列表[下标]
del mylist[0]
print(f"列表删除指定下标索引元素后结果是：{mylist}")
# 6.2 方法2：列表.pop(下标)
mylist = ["itheima","itchange","itgcxy"]
elenent = mylist.pop(0)
print(f"通过列表删除指定下标索引元素后结果是：{mylist}，取出的元素是：{elenent}")

# 7.删除某元素在列表中匹配的元素，只能删掉出现的第一个符合的元素
mylist =["itheima","itchange","itgcxy","itheima","itchange"]
mylist.remove("itheima")
print(f"列表remove方法移除元素后，列表的结果是：{mylist}")

# 8.清空全部列表
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")

# 9.统计某一个元素的数量
mylist =["itheima","itchange","itgcxy","itheima","itchange"]
count = mylist.count("itheima")
print(f"列表中itheima的数量是：{count}")

# 10.统计列表中一共有多少个元素
mylist =["itheima","itchange","itgcxy","itheima","itchange"]
count = len(mylist)
print(f"列表中一共有：{count}个元素")

三、列表的遍历

# 演示对list列表循环，使用while循环

def list_while_fun():
    '''
    使用while循环遍历列表的演示函数
    :return: None
    '''
    my_list = ["传智教育","黑马程序员","Python"]
    # 循环控制变量通过下标索引来控制，默认：0
    # 每一次循环将下标索引变量＋1
    # 循环条件：下标索引变量 < 列表的元素数量
    
    # 定义一个变量用来标记列表下标
    index = 0
    while index < len(my_list):
        # 通过index变量取出对应下标元素
        element = my_list[index]
        print(f"列表的元素：{element}")
        
        # 至关重要的一步
        index += 1

def list_for_fun():
    '''
    使用for循环遍历列表的演示函数
    :return: None
    '''
    my_list = [1,2,3,4,5,6]
    # for 临时变量 in数据容器
    for element in my_list:
        print(f"列表的元素有：{element}")
        
list_for_fun()

四、数据容器

1.元组

# 演示tuple元组的定义和操作
t1 = ("hello",True)
t2 = ()
t3 = tuple()

print(f"t1的类型是：{type(t1)},内容是：{t1}")
print(f"t2的类型是：{type(t2)},内容是：{t2}")
print(f"t3的类型是：{type(t3)},内容是：{t3}")

# 定义一个单个元组
# 如果只有单个元素就需要在单个元素的后面加“,”,才能表示元组，如果不加，输出的结果类型将是str
t4 = ("hello",)
print(f"t4的类型是：{type(t4)},内容是：{t4}")
# 元组的嵌套
t5 = ((1,2,3),(4,5,6))
print(f"t5的类型是：{type(t5)},内容是：{t5}")

# 通过下标索引去取出内容
num = t5[1][2]
print(f"从嵌套元组中取出的数据是：{num}")

# 元组的操作：index查找方法
t6 = ("传智教育","黑马程序员","Python")
index = t6.index("黑马程序员")
print(f"在元组t6中查找黑马程序员的下标是：{index}")
# 元组的操作：count统计方法
t7 = ("传智教育","黑马程序员","Python","传智教育","黑马程序员","Python")
num = t7.count("黑马程序员")
print(f"在元组t7中统计黑马程序员的数量有：{num}")
# 元组的操作：count统计方法
t8 = ("传智教育","黑马程序员","Python","传智教育","黑马程序员","Python")
num = len(t8)
print(f"t8元组中的元素有：{len(t8)}个")
# 元组的遍历：while
index = 0
while index < len(t8):
    print(f"元组中的元素有：{t8[index]}")
    # 至关重要
    index += 1

# 元组的遍历：for
for element in t8:
    print(f"2元组元素有：{element}")

元组的内容是固定的，不需要修改

# 定义一个元组
t9 = (1,2,["itheima","itcast"])
print(f"t9的内容是：{t9}")
t9[2][0] = "传智教育"
t9[2][1] = "黑马程序员"
print(f"t9的内容是：{t9}")

2.字符串

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

# index方法：查
value = my_str.index("and")
print(f"从字符串{my_str}中查找and，起始下标是：{value}")
# replace方法：替换
new_my_str = my_str.replace("it","程序")
print(f"字符串{my_str}进行替换后得到：{new_my_str}")
# split方法:分割
my_str = "itheima and itcast"
my_str_list = my_str.split(" ")
print(f"字符串{my_str}进行切割后得到：{my_str_list},类型是：{type(my_str_list)}")
# strip()方法：去掉前、后空格
my_str = "  itheima and itcast  "
new_my_str = my_str.strip() # 不传入参数去除收尾空格
print(f"字符串{my_str}被strip后，结果：{new_my_str}")

my_str = "12itheima and itcast21"
new_my_str = my_str.strip("12")
print(f"字符串{my_str}被strip后，结果：{new_my_str}")
# 统计字符串中某字符串出现的次数:count
my_str = "12itheima and itcast21"
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是：{count}")
# 统计字符串的长度：len()
num = len(my_str)
print(f"字符串{my_str}的长度是：{num}")

课后习题：

答案：

# 字符串课后练习
my_str = "itheima and itcast"
# 统计字符串内有多少个“it”字符
num = my_str.count("it")
print(f"字符串{my_str}中有：{num}个it字符")
# 将字符串内的空格，全部替换为：“|”
new_my_str = my_str.replace(" ","|")
print(f"{my_str}被替换空格后，结果为:{new_my_str}")
# 并按照“|”进行字符串的分割，得到列表
new_my_str_list = new_my_str.split("|")
print(f"{new_my_str}被分割后的字符串为：{new_my_str_list}")

3.数据容器（序列）的切片

注意：我们对序列的操作不会影响序列本身，而是会得到一个新的序列。因为元组、字符串都是不可修改的

# 对list进行切片，从1开始，4结束，步长为1
my_list = [0,1,2,3,4,5,6]
result = my_list[1:4] # 步长默认为1，所以可以省略不写
print(f"结果1：{result1}")
#对tuple切片，从头开始，到最后结束，步长为1
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[:]
print(f"结果2：{result2}")
# 对str切片，从头开始，到最后结束，步长为2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")
# 对str切片，从头开始，到最后结束，步长为-1
my_str = "01234567"
result4 = my_str[::-1]
print(f"结果4：{result4}")
# 对列表进行切片，从3开始，到1结束，步长为-1
my_list = [0,1,2,3,4,5,6]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}")
# 对元组进行切片，从头开始，到尾结束，步长为-2
my_tuple = (0,1,2,3,4,5,6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")

练习：

有字符串："万过薪月，员序程马黑来。nohtyP"，请使用学过的知识，得到”黑马程序员“

可参考：倒序字符串，切片取出，然后倒序

split分隔“，”replace替换“来”为空，倒序字符串

my_str = "万过薪月，员序程马黑来，nohtyP"
# 倒序字符串，切片取出
result1 = my_str[::-1][9:14]
print(f"方式一结果：{result1}")
#切片取出
result2 = my_str[5:10][::-1]
print(f"方式二结果：{result2}")
#split分离“,”replace替换“来”为空，倒序字符串
result3 = my_str.split(",")[1].replace("来","")[::-1]
print(f"方式三结果：{result3}")

4.数据容器：set(集合)

上述特性有局限，他们都支持重复。如果场景需要对内容做去重点处理，列表，元组，字符串就不方便了，而集合最主要的特征就是不支持元素的重复，相当于自带去重功能，且集合的内部是无序的

# 定义集合(集合不能重复，内容是无序的)
my_set = {"传智教育","黑马程序员","itheima","传智教育","黑马程序员","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)}")

# 添加元素：add
my_set.add("Python")
my_set.add("传智教育") # 添加后会被去重
print(f"添加后的元素为：{my_set}")

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

# 随机取出元素:pop
my_set = {"传智教育","黑马程序员","itheima"}
element = {f"集合被取出的元素是：{element},取出后元素为：{my_set}"}

# 清空集合:clear
my_set.clear()
print(f"集合被清空啦，结果是：{my_set}")

# 取2个集合的差集：difference(集合2)
set1 = {1,2,3}
set2 = {1,6,7,8}
set3 = set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
print(f"取差集后原有set1的内容：{set}")
print(f"取差集后原有set2的内容：{se2}")

# 消除2个集合的差集:difference_updata(集合2)
set1 = {1,2,3}
set2 = {1,6,7,8}
set1.difference_updata(set2)
print(f"消除差集后，集合1的结果：{set1}")
print(f"消除差集后，集合2的结果：{set2}")

# 2个集合合并为一个:union,不会修改已有集合，只能得到新的集合
set1 = {1,2,3}
set2 = {1,6,7,8}
set3 = set1.union(set2)
print(f"2个集合合并后的结果：{set3}")
print(f"合并后集合1：{set1}")
print(f"合并后集合2：{set2}")

# 统计集合元素数量:len()
set1 = {1,2,3,4,5,6,1,2,3,4,5,6}
num = len(set1)
print(f"集合内元素的数量有：{num}个")  # 只能识别出6个。因为集合会去重

# 集合的遍历
set1 = {1,2,3,4,5,6}
for element in set1:
    print(f"集合的元素有：{element}")

课后练习：

有如下的列表对象：

my_list = ['黑马程序员','传智教育','黑马程序员','传智博客','itheima','itcast','itheima','itcast','best']

请：1.定义一个空集合

2.通过for循环进行遍历列表

3.在for循环中将列表的元素添加至集合

4.最终得到元素去重后的集合对象，并打印输出

5.数据容器：dict（字典、映射）

（1）字典的基础定义：与集合一样同样使用{},不过存储的元素是一个个的键值对，如下面的语法

# 定义字典字面量
{key:value,key:value,........,key:value}
# 定义字典自变量
my_dict = {key:value,key:value,........,key:value}
# 定义空字典
my_dict = {}
my_dict = dict()
# 定义字典
my_dict1 = {王力宏:99,周杰伦:88,林俊杰:77}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是：{my_dict1},类型是：{type(my_dict1)}")
print(f"字典2的内容是：{my_dict2},类型是：{type(my_dict2)}")
print(f"字典3的内容是：{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_dict["王力宏"]
print(f"王力宏的考试成绩为：{score}")

# 定义嵌套字典,字典的key和value可以是任意数据类型（key不可为字典）
stu_score_dict = {
    "王力宏":{
        "语文":77,
        "数学":66,
        "英语":99
    },
    "周杰伦":{
         "语文":99,
         "数学":33,
         "英语":88
    },
    "林俊杰",{
         "语文":88,
         "数学":66,
         "英语":77
    }
}
print(f"学生的考试信息是：{stu_score_dict}")
# 从嵌套字典中获取数据
score = stu_score_dict["周杰伦"]["语文"]
print(f"周杰伦的语文信息是：{score}")

(2)字典的常用操作

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

# 遍历字典
# 方式一：通过获取全部的key来遍历
for key in keys:
    print(f"字典的key是：{key}")
    print(f"字典的vaule是：{my_dict[key]}")    
#方式二：直接对字典进行for循环
for key in my_dict:
     print(f"2字典的key是：{key}")
     print(f"2字典的vaule是：{my_dict[key]}")    

# 统计字典的元素数量：len()
num = len(my_dict)
print(f"字典中有：{num}个元素")

课后作业：

答案：

# 组织字典记录数据
info_dict = {
    "王力宏":{
        "部门":"科技部",
        "工资":3000,
        "级别":1
    },
    "周杰伦":{
         "部门":"市场部",
         "工资":5000,
         "级别":2
    },
    "林俊杰":{
         "部门":"市场部",
         "工资":7000,
         "级别":3
    },
    "张学友":{
         "部门":"科技部",
         "工资":4000,
         "级别":1
    },
    "刘德华":{
         "部门":"市场部",
         "工资":6000,
         "级别":2
    }
}

print(f"对员工进行升职加薪前的结果:{info_dict}")

# for循环遍历字典
for key in info_dict:
    # if条件判断符合条件的员工
    if info_dict[name]["级别"] == 1:
        # 升职加薪的操作
        # 获取员工的信息字典
        employee_info_dict = info_dict[name]
        #修改员工信息
        employee_info_dict["级别"] = 2
        employee_info_dict["工资"] += 1000
        #将员工的信息变更为info_dicet
        info_dict[name] = employee_info_dict

# 输出结果
print(f"对员工进行升职加薪的结果:{info_dict}")

6.数据容器的对比

7.数据容器的通用操作

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 = {"key":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)}")
# main与上max相同的用法

# 类型转换：容器转元组
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"列表转字符串的结果是：{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"列表转集合的结果是：{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"列表转容器的结果是：{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 = [1,5,4,6,2,3]
my_tuple = (1,5,4,6,2,3)
my_str = "bcagdef"
my_set = {1,5,4,6,2,3}
my_dict = {"key":1,"key2":2,"key3":3,"key4":4,"key5":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}")

8.字符串大小比较

字符串是按位比较的，也就是一位位进行对比，只要一位大那么整体就大

都是比较字符串的码值，也就是ASCll码

# abc比较大小
print(f"abd大于abc,结果：{'abd'>'abc'}")
# key1比较key2
print(f"key1大于key2,结果：{'key2'>'key1'}")

第七章函数进阶

一、函数多返回值

# 演示使用多个变量，接收多个返回值
def test_reutrn():
    return 1,"hello",True

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,'男')  
# 关键字参数，可以不按照参数的定义传参
user_info(name='笑笑',age='10',gneder='女')
user_info('甜甜',age='5',gneder='女')
# 缺省参数，默认参数必须写在最后
def user_info(name,age,gender='男'):
    print(f"姓名是:{name},年龄是:{age},性别是:{gender}")
    
user_info('小天'，13)
user_info('小填'，18,gender='男')

# 位置不定长，*号
# 不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入
def_user_info(*args):
    print(f"*args参数的类型是：{type(args),内容是：{args}}")

user_info(1,2,3,'小民','男孩')
# 关键字不定长，**号
def_user_info(**kwargs):
    print(f"*args参数的类型是：{type(kwargs),内容是：{kwargs}}")

user_info(name='小王',age=11,gender='男孩')

三、匿名函数

1.函数作为参数传递

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

# 调用，并传入函数
test_func(compute)

# 函数本身是可以作为参数，传入另一个函数中进行使用的；将函数传入的作用在于：传入计算逻辑，而非传入数据

2. lambda匿名函数

# 定义一个函数，接受其他函数输入
def test_func(compute):
    result = compute(1,2)
    print(f"计算结果：{result}")
# 通过lambda匿名函数的形式，将匿名函数作为参数传入
test_func(lambda x,y:x + y) #不可以通过回车写多行