python

python常用的网站:
Python中的内置函数: https://docs.python.org/zh-cn/3.13/library/functions.html
Python中的模块: https://docs.python.org/zh-cn/3.13/py-modindex.html

1. pycharm常用快捷键

2. 字面量

字面量就是写在代码中的具体的值

例如下面的值

"张三"
18
65.2

"李四"
55
74.6

"王五"
25
80

写在pythOn 文件头部的字符串，会被自动识别成docstring，也就是文档字符串。文档字符串必须使用三个字符串包裹。

3. 变量

在python中，变量其实就是一个代号，用来和某个值建立绑定关系

之所以交变量，是因为他和某个值的绑定关系，可以随时改变

语法: 变量名 = 值

name = '张三'

4. 标识符的命名规则

1. 只能包含: 数字、字母、下划线，且不能以数字开头，不饿能包含空格
2. 标识符区分大小写
2. 标识符不能使用关键字
3. 标识符尽量不要与内置函数同名
4. 标识符虽然没有长度限制，但应追求: 简洁清晰，具有描述性

5. 常量

一旦被赋值，不希望被修改的变量，称之为常量

常量命名规则:

1. 常量名通常使用大写字母，多个单词之间用下划线连接
2. 常量一旦赋值，就不能被修改

Python中没有强制的常量机制，Python中所谓的变量，其本质其实还是变量，只不过我们约定好不去修改

例如

AGE = 18

6. 注释

在python中多行注释的本质就是三个字符串包裹的一段文字

单行注释: #
多行注释: ''' ''' 或 """ """
文档编码注释: 写在python文件头部，用于指定当前文件的字符编码

单行注释不能换行，只有多行注释才可以换行

字符编码

存数据时采用的编码格式，决定了数据读取的编码格式。两者必须一致

7. 数据类型

1. 字符串(str)

2. 整形（int）

3. 浮点型（float）

4. 布尔值（bool）

在python中，可以使用type()函数，查看某个值的数据类型

在python中，变量是没有类型的，值是有类型的

8. 整型

# 所谓整型，就是没有小数点的数字，可以是正数，也可以是负数，也可以是0
import sys

age = 18
temp = -15
score = 0

# 当数很大时，我们可以使用下划线将数字进行分组，来让数字变得更易读

salary = 300_000
house_price = 3_200_000

# python中整数的上限值，取决于执行代码的计算机的内存和处理能力

a = 9 ** 9999
sys.set_int_max_str_digits(0)
b = a + 100
print(b)

9. 浮点型

# 浮点型就是带有小数点的数字
weight = 65.2
balance = 1425.58
out_temp = -25.2
price = 120.0

print(type(weight))
print(type(balance))
print(type(out_temp))
print(type(price))


# 浮点型的科学计数法表示.

speed_of_sound = 3.4e+2 #3.4乘以10的2次方
world_population = 7.8e9 #7.8乘以10的9次方
distance_sun_earth = 1.496E8 #1.496 乘以10的8次方

print(speed_of_sound)
print(world_population)
print(distance_sun_earth)

one_ml = 1e-3  # 1乘以10的-3次方

10. 字符串的四种定义方式

# 单引号和双引号是不能直接换行的
# 单引号和双引号的写法是等价的，二者都不能直接换行(要用圆括号才能换行),单引号用的多
message1 = '尚硅谷,让天下没有难学的技术!'
message2 = "尚硅谷,让天下没有难学的技术!"
# 三个单引号的写法，可以直接换行，并且可以作为多行注释使用
message3 = '''尚硅谷,让天下没有难学的技术!'''
# 三个双引号的写法，可以直接换行，也可以作为多行注释使用，还能作为文档字符串使用
message4 = """尚硅谷,让天下没有难学的技术!"""

print(message1)
print(message2)
print(message3)
print(message4)

11. 格式化输出

name = "张三"
gender = "男"
weight = 35.2
age = 12

# 写法一: 直接用加号进行拼接,写起来很麻烦且代码很乱，而且只能是字符串之间拼接
info1 ='我叫' + name + '我是,' + gender + '生'
print(info1)

# 写法二: 使用占位符

# %s占位字符串，%f 展位浮点数， %i占位整数，%d占位十进制的整数，%s是万能的
info2 ='我叫%s,我是%s生,我的体重是%f,年龄是%d' % (name,gender,weight,age)
print(info2)

# 写法三: 使用f-string (最推荐的方式)

info3 = f'我叫{name},我是{gender}生，我体重是{weight},年龄是{age}'
print(info3)

12. 字符串占位符精度控制

字符串占位
%m.ns
m:

1. 字符串的最小宽度，位数不够会自动使用空格补齐，位数小于字符串长度则不起作用
2. 正数是右对齐，负数是左对齐

n:

1. 精度控制，最多输出n个字符(若n大于实际字符串长度，则不起作用)

字符串占位

%m.nf

m:

1. 控制整体宽度(整体宽度 = 整数宽度 + 小数点 + 小数宽度)
2. 位数不够空格来补，位数小于整体宽度，则自动失效
3. 正数是右对齐，负数是左对齐

n:

1. 精度控制，保留n位小数，默认值是6,不够6位是会使用0补位,如果需要截断，是需要四舍五入的

整数占位

%m.nd

m:

1. 最小宽度，位数不够会自动使用空格补齐，位数小于整数位数，则自动失效

2. 正数是右对齐，负数是左对齐

n:

1. 精度控制，含义: 最少用n位显示数字
2. 位数不够用0来补，位数小于整数位，则自动失效

# 字符串占位符精度控制

"""
字符串的占位
%m,n
m是字符串的宽度
n是字符串的精度

m是正数，向右对齐
m是复数，向左对齐

浮点数的占位
精度控制，保留n位小数，默认值是6,不够6位是会使用0补位,如果需要截断，是需要四舍五入的

整数的占位

m过小自动失效
m过大使用空格补齐

n过小,自动失效
n过大,使用0补齐
"""

name = "张三"
gender = "男"
weight = 35.2
age = 12

info ='我叫%4.4s,我是%s生,我的体重是%f,年龄是%d' % (name,gender,weight,age)
print(info)

13. 转义字符

# 转移字符

# 写法一: 使用双引号
print("在python中，可以使用'包裹一个字符串")
# 写法二:使用转移字符
print('在python中，可以使用\'包裹一个字符串')
print('在python中，可以使用\"包裹一个字符串')

# 使用\n进行换行
print("注册会员需要以下信息: \n姓名\n年龄\n手机号")

# 使用\\输入\
print("\\")

# 使用\b 删除前一个字符
print("helloo\b")

# 使用 \r 使光标回到本行开头，覆盖输出
print('67%\r68%')

# 使用 \t: 水平制表符(让光标跳转到下一个制表位)
print('ab\tcd')


# 表明在什么环境下，制表位都是4个空格
print('ab\tcd'.expandtabs(4))
print('abc\td'.expandtabs(4))

14. 数据类型转换

把指定数据转为字符串,任何类型都可以转成字符串类型

result1 = str(18)
result2 = str(75.6)

print(result1)
print(result2)

使用str()将指定数据转换为字符串

result1 = str(18)
result2 = str(75.6)
result3 = str(1.8e3)
result4 = str(12_000)

print(type(result1), result1)
print(type(result2), result2)
print(type(result3), result3)
print(type(result4), result4)

把指定数据转为整型: int()

result5 = int(15.6)
result6 = int("79")
result7 = int("   79    ")
result8 = int(48)

print(type(result5), result5)
print(type(result6), result6)
print(type(result7), result7)
print(type(result8), result8)

把指定数据转为浮点型: float()

result9 = float(18)
result10 = float("15.6")
result11 = float("   5.7    ")
result12 = float(14.8)
result13 = float("48")

print(type(result9), result9)
print(type(result10), result10)
print(type(result11), result11)
print(type(result12), result12)
print(type(result13), result13)

把指定数据转为布尔类型: bool()

Python中除0以外的任何数,转为布尔值后都为True,只关心是不是0,0为False，非0为True

result9 = float(18)
result10 = float("15.6")
result11 = float("   5.7    ")
result12 = float(14.8)
result13 = float("48")

print(type(result9), result9)
print(type(result10), result10)
print(type(result11), result11)
print(type(result12), result12)
print(type(result13), result13)

Python中除空字符串以外的任何数,转为布尔值后都为True

15. 算数运算符

# 算数运算符

"""
+ 加
- 减
* 乘
/ 除
// 取整
% 取模或取余
** 指数
"""

16. 赋值运算符

age = 18    #赋值运算符

age = age + 1 等价于 age += 1    # 加法 复合赋值运算符
age = age - 1 等价于 age -= 1    # 减法 复合赋值运算符
age = age / 2 等价于 age /= 1    # 除法 复合赋值运算符
age = age // 2 等价于 age //= 1    # 取整 复合赋值运算符
age = age % 2 等价于 age %= 1    # 取模 复合赋值运算符
age = age % 2 等价于 age %= 1    # 取模 复合赋值运算符
age = age ** 2 等价于 age **= 1    # 指数 复合赋值运算符

17. 比较运算符

==      判断左右两侧是否相等
!=      判断左右两侧是否不相等
>       判断左侧是否大于右侧
>=      判断左侧是否大于等于右侧
<       判断左侧是否小于右侧
<=      判断左侧是否小于等于右侧

18. 布尔类型

# 布尔类型
a = True
b = False

c = 7 > 3
d = 7 < 2

print(type(a),a)
print(type(b),b)
print(type(c),c)
print(type(d),d)


# 布尔类型是int类型的子类型，底层的本质是用1表示True, 用0表示False

print(4 + True)  # 5
print(8 - False) # 8
print(True + True) #2
print(False - False) #0


# 使用bool将指定内容转换为布尔类型
print(bool(1))
print(bool(0))

19. 逻辑运算符

# and 用于判断其两侧的值，是否都为True
print(True and True)
print(True and False)
print(False and True)
print(False and False)

# and具备逻辑短路的能力

print(False and 3/0)  # False

# and返回的不一定是布尔值，它返回的是某个参与计算的值本身
# 规则: and会先看左边，如果左边是"假"，就直接返回左边，否则返回右边
# 备注: 若参与and的值不是布尔值，那Python会自动转换为布尔值，然后再进行逻辑操作


# or 用于判断其两侧，是否至少有一个为True(只要有一个是True,那就返回True)

print(True or True)
print(True or False)
print(False or True)
print(False or False)

# or具备逻辑短路的能力
print(True or 3/0)
print(9 > 3 or 3/0)


# or返回的也不一定是布尔值，它返回的是参与计算的值本身
# 规则: or会先看左边，如果左边是"真"，就直接返回左边，否则返回右边
# 备注: 若参与or的值不是布尔值，那Python会自动转换为布尔值，然后再进行逻辑操作



# not 用于取反
# 备注: 若参与not的值不是布尔值，那Python会自动转换为布尔值，然后再进行逻辑操作


print(not True)
print(not False)
print(not 3 > 2)
print(not 3 < 2)

#not 返回的值，一定是布尔值

20. 进制

10进制转其他进制字符串

bin(10) # 十进制转二进制字符串
oct(10) # 十进制转八进制字符串
hex(10) # 十进制转十六进制字符串

其他进制转为十进制数字

使用int()将指定进制的数,转为十进制数字
int('0b11001', 2) # 转为二进制
int('0o1034', 8) # 转为八进制
int('0x1cf', 16) # 转为十六进制

21. 输入语句

name = input("请输入你的姓名: \n")
age = input("请输入你的年龄: \n")
age = int(age)
print(f'{name},你今年的年龄是{age}')
print(f'{name},你明年的年龄是{age + 1}')

22. 流程控制语句

单分支(基于判断实现)

age = input("请输入您的年龄: \n")
age = int(age)
if age >= 18:
    print('你是成年人')
    print('成年人的世界，虽不容易，但很精彩!')

print("================================")

双分支

age = input("请输入您的年龄: \n")
age = int(age)
if age >= 18:
    print('你是成年人')
    print('成年人的世界，虽不容易，但很精彩!')
else:
    print("你是未成年人")
    print("好好加油，努力学习，未来可期!")

print("欢迎你来学习python")

多分支

age = input("请输入您的年龄: \n")
age = int(age)
if age <= 10:
    print('你是幼儿')
elif age <= 18:
    print("你是青少年")
elif age <= 30:
    print("你是青年")
elif age <= 50:
    print("你是中年")
elif age <= 60:
    print("你是中老年")
else:
    print("您是老年")

嵌套分支

age = input("请输入您的年龄: \n")
has_report = input("您是否提交了体检报告?(是/否)")
level = int(input('请输入您的会员等级(1/2/3)'))
age = int(age)

print("*****程序的识别结果如下******")
if  18 <= age <= 45:
    print("您的年龄符合比赛要求!")
    if has_report == '是':
        print("您已提交体检报告！")
        print("您可以参加比赛")

        if level == 1:
            print(f'尊敬的{level}级会员，比赛结束后，您可以领取纪念T恤一键')
        elif level == 2:
            print(f'尊敬的{level}级会员，比赛结束后，您可以领取纪念T恤一键')
        elif level == 3:
            print(f'尊敬的{level}级会员，比赛结束后，您可以领取纪念T恤一键')
        else:
            print("您的会员等级不符")
    elif has_report == '否':
        print("您未提交体检报告，不能参加比赛")
    else:
        print("您输入的体检报告有误!")
else:
    print("抱歉,您的年龄不符合比赛要求!")

23.while循环

n = 1
while n <= 10:
    print(f'你好啊====={n}')
    n += 1

案例

print("您现在身处密室，需要正确回答问题之后，才能逃出密室!")
riddle = '你是什么人?'
answer = '你的心上人'
guess = ''

while guess != answer:
    print(f'问题: {riddle}')
    guess = input('请输入答案：\n')
    if guess == answer:
        print('答案正确,逃脱成功!')
    else:
        print('回答错误，请再想想!')

24.for循环

for 当前取出的值 in 可迭代对象: 要执行的循环操作1 要执行的循环操作2

for n in range(10):
    print('你好啊',n)

25. while循环与for循环的区别

1. while循环是先判断条件，再执行循环体
2. for循环是先取出可迭代对象中的值，然后再执行循环体
3. 一般情况下，for循环的性能要优于while循环
4. 当不确定循环次数时，使用while循环；当确定循环次数时，使用for循环

26. for循环实现99乘法表

for i in range(1, 10):  # 外层循环控制行数
    for j in range(1, i + 1):  # 内层循环控制列数，从1到当前i的值
        print(f'{j}x{i}={i*j}', end='\t')  # 打印乘法表的一项并使用制表符分隔
    print()  # 每完成一行后换行

27. contine 和 break

1. continue 和 break 在for循环和wile循环中都可以使用
2. continue 用于结束本次循环，但不退出整个循环
3. break 用于结束整个循环
4. coontinue 和 break 都只在当前循环有效

28. 流程控制综合案例

# 流程控制综合案例
print('欢迎来到: 答题闯关挑战赛(输入q可随时退出)')

# 题目与答案
ques1,ans1 = 'Python中用于输入的函数是?','print'
ques2,ans2 = 'Python中用于表示逻辑“并且”的关键字是?','and'
ques3,ans3 = 'Python属于编译型还是解释型?','解释型'

# 最多可尝试次数
max_tries = 3

# 总关卡数
total_levels = 3

# 是否处于可游戏状态
is_playing = True

for level in range(1,total_levels + 1):
    print(f'*********第{level}关*********')
    if level == 1:
        question,answer = ques1,ans1
    elif level == 2:
        question, answer = ques2, ans2
    else:
        question, answer = ques3, ans3
    # 若已经尝试的次数，小于等于最大尝试次数，则进入循环
    tries = 1
    while tries <= max_tries:
        user_input = input(f'{question} \n')
        if user_input == answer:
            print('回答正确!')
            break
        elif user_input == '':
            print('您的输入为空，请重新作答!')
            continue
        elif user_input == 'q':
            print('您已退出游戏!')
            is_playing = False
            break
        else:
            # 计算剩余次数
            leave = max_tries - tries
            if leave > 0:
                print(f'回答错误，您还剩{leave}次机会!')
                tries += 1
                continue
            else:
                print(f'挑战失败，本题的正确答案是: {answer},游戏结束!')
                is_playing = False
            continue

    if not is_playing:
        break

    if is_playing:
        print('恭喜您，全部通关')

29. 函数

函数是组织好的、可重复使用的、用于执行特定任务的代码块

Python中函数的分类

1. 内置函数
   无需要任何操作，直接就能使用的函数
2. 模块提供的函数
   需要导入指定的模块后，才能使用。
3. 自定义函数
   程序员自己定义的函数(先定义再使用)

30. 函数的基本使用

# 函数
def welcome():
    print('欢迎来到尚硅谷课堂!')
    print('尚硅谷，让天下没有难学的技术!')
welcome()

31. 函数参数的使用

# 函数参数的使用
def order(num, dish):
    print(f'您点的是: {num}份 {dish}')


order(1, '辣椒炒肉')

32. 函数_位置参数

# 位置参数
# 位置参数: 调用函数时，根据参数在函数定义中出现的顺序，把实参的值一次传递给对应的形参
def greet(name,gender,age,height):
    print(f'我叫{name},性别{gender},年龄{age}岁,身高是{height}cm')

greet('张三','男',18,172)

33. 函数_关键字参数

使用关键词参数时，位置参数必须在关键字参数之前

# 关键字参数: 在调用函数时，根据形参的名字来传递实参的值

def greet(name,gender,age,height):
    print(f'我叫{name},性别{gender},年龄{age}岁,身高是{height}cm')

greet(name='张三', age=18, gender='男',  height=172)

34. 限制传参方式

具体规则:

1. /前边只能用位置参数，*后面只能用关键字参数
2. / 和 * 同时使用时，/必须在*前面

# 限制传参方式
#具体规则: /前边只能用位置参数，*后面只能用关键字参数
# / 和 * 同时使用时，/必须在*前面
def greet(name,/,gender,*,age,height):
    print(f'我叫{name},性别{gender},年龄{age}岁,身高是{height}cm')

# greet('张三','男',18,172)
greet('张三', age=18, gender='男',  height=172)

35. 默认参数

定义函数时，通过形参名=值的形式，为参数指定一个默认值

默认参数必须要放在必选参数的后面，或者说: 某个形参，一旦设置了默认值，那么该参数就必须放在非必选参数的后面

如果没传默认参数，那么该参数使用默认值，如果传了默认参数，那么该参数使用传入的值

def greet(name,gender='男',age=18,height=172):
    print(f'我叫{name},性别{gender},年龄{age}岁,身高是{height}cm')

greet('张三')

36. 可变参数

位置参数: 定义函数时，在形参名前加*，表示该参数可以接收任意数量的位置参数，并打包成一个元组
关键字参数：定义函数时，在形参名前加**，表示该参数可以接收任意数量的关键字参数，并打包成一个字典

可变位置参数、可变关键字参数，可以同时使用，但必须先写可变位置参数
可变位置参数，可变关键字参数，也能与其他类型的参数一起使用

# 定义函数(使用*args)去接收: 可变位置参数
# 定义函数(可变位置参数)
def test1(*args):
    print(args)

test1('张三','男',18,172)
# 定义函数(可变关键字参数)
def test2(**kwargs):
    print(kwargs)

test2(name='张三',gender='男',age=18,height=172)

# 定义函数(同时使用,可变位置参数，可变关键字参数)
def test3(*args,**kwargs):
    print(args)
    print(kwargs)

test3('张三','男',age=18,height=172)

37. 特殊的字面量_None

# None
#NoneType类型: None

# 1.None是一个特殊的字面量，它表示: 空值/无值/无意义
msg = None
# 2.None的类型是NoneType
print(type(msg))
# 3.None转为布尔值是False
print(bool(msg))
# 4.None不能参与数学运算，也不能与字符串拼接
# result1 = msg + 1
# 5.不给函数设置返回值，函数会默认返回None

38. 函数的返回值

函数返回值: 函数执行完毕后，会把执行结果交给调用者，这个执行结果就是返回值

return关键字: retrun会结束函数执行,并把return后的值，作为函数的返回值

def add(n1,n2):
    print(f'我收到了: {n1}、{n2},二者相加是: {n1 + n2}')
    return n1 + n2
result = add(100,200)

39. 全局作用域 vs 局部作用域 以及global关键字的使用

什么是作用域? ---- 变量能起作用的范围(变量在哪里能用，在哪里不能用)。

1. 全局作用域: 整个.py文件最外层的范围，就是全局作用域
2. 局部作用域: 在函数内部，就是局部作用域,只能在当前函数中使用

局部作用域和局部作用域，会在函数调用时创建，在函数执行后销毁

# 全局作用域和局部作用域
a=100
b=200
def test():
    c='尚硅谷'
    d='你好啊'
    a = 300
    print(a) # 300
    print(b)
    print(c)
    print(d)

test()

print(a) # 100
print(b)
# print(c)   报错
# print(d)   报错


def test():
    c='尚硅谷'
    d='你好啊'
    global a # 声明n是全局变量
    a = 300
    print(a) # 300
    print(b)
    print(c)
    print(d)

test()

print(a) # 300
print(b)
# print(c)   报错
# print(d)   报错

40. 函数的嵌套调用

在一个函数的执行过程中，去调用了另外一个函数

41. 函数的递归调用

递归调用: 是指函数自己调用自己的一种操作。

# 递归调用
def welcome(n):
    print(f'你好啊!----------{n}')
    if n > 1:
        welcome(n - 1)
welcome(5)

# 输出 
# 你好啊!----------5
# 你好啊!----------4
# 你好啊!----------3
# 你好啊!----------2
# 你好啊!----------1


def welcome(n):
    if n > 1:
        welcome(n - 1)
    print(f'你好啊!----------{n}')
welcome(5)

# 输出 
# 你好啊!----------1
# 你好啊!----------2
# 你好啊!----------3
# 你好啊!----------4
# 你好啊!----------5

原理是: 待执行函数的调用，会形成一个栈结构，当函数执行完毕后，就会从栈中弹出。
这两段代码在递归时，其实都需要逐层压栈，二者调用深度完全相同，只是打印的时机不同。

42. 递归的应用

# 递归的应用
#使用递归求一个数的阶乘
# 某个数的阶乘就是: 所有小于及等于

def factorial(num):
    if num == 0:
        return 1
    else:
        return num * factorial(num - 1)

result = factorial(5)

print(result)

43. 函数的说明文档

说明文档: 写在函数里的文字说明，用来描述: 函数的功能、需要哪些承诺书、返回什么结果。

# 函数的说明文档
# 接收两个数字: n1、n2，返回二者相加的结果

def add(n1, n2):
    """
    计算两个数相加的结果
    :param n1: 第一个数
    :param n2:  第二个数
    :return:  二者相加的结果
    """
    return n1 + n2


result = add(100,500)


print(result,'result========')

44. 函数_综合案例

# 函数综合案例

def calc_total(*nums):
    """
    计算总运动量
    :param nums: 每一天的运动量（可变参数）
    :return: 总运动量(个)
    """
    return sum(nums)


def calc_avg(total, days=3):
    """
    计算平均值
    :param total: 总运动量
    :param days: 天数(默认值是7)
    :return: 平均值
    """
    return total / days


def check_success(total, goal=120):
    """
    判断本次挑战是否成功
    :param total: 总运动量
    :param goal: 目标运动量
    :return: 成功或失败的具体信息
    """
    print(total)
    print(goal)
    if total >= goal:
        return '恭喜!挑战成功!'
    else:
        return '抱歉！挑战失败!'


def main(title, duration,goal):
    """
    主函数，用于开始一场挑战赛
    :param title: 比赛标题
    :param duration: 比赛持续天数
    :param goal: 目标运动量
    :return: None
    """
    print(f'【{title}】【{duration}】天挑战赛(请输入每天的数量)')
    num1 = int(input('第1天: '))
    num2 = int(input('第2天: '))
    num3 = int(input('第3天: '))
    # 计算总数
    total = calc_total(num1, num2, num3)
    # 计算平均值
    avg = calc_avg(total,duration)
    # 判断挑战是否成功
    result = check_success(total,goal)
    print(f'【{title}】【{duration}】天健身总结')
    # print('总数: %d,平均数: %.1f'% (total, avg))
    print(f'总数: {total},平均数: {avg:.1f}')
    print(result)


main('仰卧起坐', 3,30)

数据容器

1. 何为数据容器

数据容器: 一种能存放多个数据的数据类型

数据容器可以更高效的管理成批的数据，且便于存储、访问

容器中的每一个数据，又称: 每一个元素 Python中有很多中数据容器

2. 列表

1. 定义列表

# 列表
list1 = [34,56,21,56,11]
list2 = ['北京','尚硅谷','你好啊']
list3 = [23,'尚硅谷',True,None]
list4 = [23,'尚硅谷',True,None,[100,200,300]]


# 定义空列表(列表中的数据，后期会通过特定写法填充)
list5 = []
list6 = list()
print(list1,type(list1))
print(list2,type(list2))
print(list3,type(list3))
print(list4,type(list4))
print(list5,type(list5))
print(list6,type(list6))

2. 列表_ 下标

下标(索引值): 列表中元素的位置编号

正索引: 从左往右数，起始元素是0，随后是1，依次类推 负索引: 从右往左数，起始元素是-1，随后是-2，依次类推

#定义一个列表
nums = [10,20,30,40,50]

# 正索引
print(nums[0])
print(nums[1])
print(nums[2])
print(nums[3])
print(nums[4])

# 负索引
print(nums[-1])
print(nums[-2])
print(nums[-3])
print(nums[-4])
print(nums[-5])


# 定义一个嵌套列表
nums2 = [10,20,['你好啊','尚硅谷'],40,50]
# 取出"尚硅谷"
print(nums2[2][1])

3. 列表_增删改查

新增操作:

append() 添加元素到列表的末尾
insert() 在列表的指定位置插入一个元素
extend() 将可迭代对象中的内容一次取出，追加到列表的尾部

删除操作:

pop() 删除指定位置的元素，并返回被删除的元素 语法: 列表.pop(下标) 默认删除最后一个元素，返回被删除的元素值
remove() 删除列表中第一次出现的指定元素 语法: 列表.remove(元素值)
clear() 清空列表中的所有元素 语法: 列表.clear()
del 列表下标 删除指定位置的元素 语法: del 列表[下标]

# 定义一个空列表

nums = [10,20,30,40]
# 向列表尾部追加一个元素
nums.append(1)
# 语法: 列表.append(元素)
print(nums)

# 在列表指定下标处添加一个元素
nums.insert(2,666)
print(nums)
# 语法: 列表.insert(下标，元素)


# 将可迭代对象中的内容一次取出，追加到列表的尾部
nums.extend([70,80,90])
print(nums)
# 语法: 列表.extend(下标，元素)

修改操作:

通过下标修改指定位置的元素 语法: 列表[下标] = 新值

查询操作:

通过下标查询指定位置的元素 语法: 列表[下标]

4. 列表_常用方法

1. 列表.index(值) 查找指定元素在列表中第一次出现的下标 返回值: 元素下标 只在第一层列表查找

fruits = ['香蕉','苹果','橙子','香蕉']
result = fruits.index('香蕉')
print(result)

2. 列表.count(值) 统计某个元素在列表中出现的次数 返回值: 元素出现的次数

nums = [10,20,10,30,10,40,[10,10,10]]
result = nums.count(10)
print(result)

3. 列表.reverse() 反转列表(会改变原列表) 返回值: 无

nums = [10,20,10,30,10,40,[10,10,10]]
nums.reverse()
print(nums)

4. 列表.sort(reverse=布尔值) 对列表进行排序(从小到大，会改变原列表) reverse 用于控制排序方式 返回值: 无

nums = [10,20,10,30,10,40,[10,10,10]]
nums.sort(reverse=True)
print(nums)

5. 常用的内置容器

1. 使用内置的sorted函数，返回一个排序后的新容器(不改变原容器,默认顺序: 从小到大)

nums = [23,11,32,30,17] result = sorted(nums) print(result)

2. 使用内置的len函数，获取容器中元素的总数量，返回值是: 元素总数量

nums = [10,20,10,30,10,40,[50,60,70]] result = len(nums) print(result)

3. 使用内置的max函数，获取容器中的最大值，返回值是: 最大值

nums = [23,11,32,30,17] result = max(nums) print(nums) print(result)

4. 使用内置的min函数，获取容器中的最小值，返回值是: 最小值

nums = [23,11,32,30,17] result = min(nums) print(nums) print(result)

5. 使用内置的sum函数，对容器中的数据进行求和,元素只能是数值

nums = [23,11,32,30,17] result = sum(nums) print(nums) print(result)

5. 列表·循环遍历

把容器中的元素依次取出,并执行后续操作的过程,称为: 循环遍历

1. 使用while循环遍历列表

# 定义一个成绩列表
score_list = [62,50,60,48,80,20,95]
index = 0
while index < len(score_list):
    print(score_list[index],end=',')
    index += 1

2. 使用for循环遍历列表

写法1

# 定义一个成绩列表
## for循环遍历
for item in score_list:
    print(item,end=',')

写法2

# 定义一个成绩列表
## for循环遍历
for index in range(len(score_list)):
    print(score_list[index])

写法3

可以同时获取index和item

# 定义一个成绩列表
## for循环遍历
for index,item in enumerate(score_list):
    print(index,item)

enumerate可以传入第二个参数，表示从指定值开始计数

# 定义一个成绩列表
## for循环遍历
for index,item in enumerate(score_list,5):
    print(index,item)

6. 列表_特点总结

1. 可存放不同类型的元素
2. 元素是有序存储的(正索引、负索引)
3. 列表中的元素允许重复
4. 元素是允许修改的(增删改查其他操作)
5. 长度不固定，可以随着操作自动调整大小

列表是最常用的数据容器，当遇到要"存储一批数据"的场景时，首选列表

7. 元组

元组是一种和列表类似的数据容器，它和列表的区别是: 元素中的元素不可修改。

# 定义一个元组
t1 = (1,5,6,7,8,9)
print(t1,type(t1))

# 元组中如果存放了可变类型(列表),那可变类型中的内容仍可修改

t3 = (28,67,21,67,11,[100,200,300,('你好','尚硅谷')])

t3[5][2] = 400

print(t3)

1. 元组常用的方法

# 获取指定元素在元组中第一次出现的下标
result = t3.index(67)
print(result)

# 统计元组中
result = t3.count(67)
print(result)

2. 元组中常用的内置函数

res = max(t3)
print(res)
res = min(t3)
print(res)
res = len(t3)
print(res)
res = tuple(sorted(t3))
print(res)

3. 元组的循环遍历

t4 = (28,67,21,67,11)
index = 0
while index < len(t4):
    print(t4[index])
    index += 1

4. 函数调用时，使用*对列表或元组进行解包后，再传递参数

def test(*args):
    print(f'我是test函数，我收到的参数是: {args}, 参数类型是: {type(args)}')

list1 = [100,200,300,400]
tuple1 = ('你好','北京','尚硅谷')

test(*list1)
test(*tuple1)

5. 元组(tuple)_特点

1. 可存放不同类型的元素
2. 元素是有序存储的(正索引、负索引)
3. 元组中的元素允许重复
4. 元组中的元素不允许修改
5. 元组的长度固定，一旦创建就不能修改大小

元组是一种只读的数据容器，想保存一批"不会变的数据"时，首选元组。

8. 字符串

字符串就是存放多个字符的容器

1. 字符串是不可变的
2. 字符串不能嵌套

1. 字符串常用的方法

index方法： 获取指定字符在字符串中第一次出现的下标

msg = 'welcome to atguigu'
result = msg.index('t')
print(result)

split方法: 将字符串按照指定字符进行分隔，并返回一个列表

msg = '尚硅谷@atguigu@你好'
result = msg.split('@')
print(result)

replace方法: 将字符串中的某个字符串片段，替换成目标字符串

msg = 'welcome to atguigu'
result = msg.replace('atguigu','尚硅谷')
print(result)

count方法: 统计字符串中某个字符出现的次数

msg = 'welcome to atguigu'
result = msg.count('t')
print(result)

strip方法: 从某个字符串中删除指定字符串中的任意字符串
规则: 从字符串两端开始删除，直到遇到第一个不再指定字符串中的字符就停下
默认会去掉字符串两边的空格

msg = '666尚6硅6谷666'
result = msg.strip('6')
print(msg)
print(result)#尚6硅6谷


msg = '1234尚12硅34谷4321'
result = msg.strip('1324')
print(result) #尚12硅34谷

2. 常用的内置函数

len函数: 统计字符串中，字符的个数(字符串长度)
max函数：返回字符串中Unicode编码值最大的字符，不是下标
min函数：返回字符串中Unicode编码值最小的字符，不是下标
sorted函数：将字符串按Unicode编码值进行排序，返回一个新的列表

9. 序列

学列: 能联系存放元素的数据容器，元素有先后顺序，且可以通过下标访问

切片: 从序列中按照指定范围，取出一部分元素，形成一个新的序列的操作

语法: 序列[起始索引:结束索引:步长]

list1 = [10,20,30,40,50,60,70,80,90,100]

list2 = list1[0:10:1]
# 等价于
list3 = list1[::]

list4 = list1[:999:]

print(list2)
print(list3)
print(list4)


list5 = list1[3::]
print(list5)

list6 = list1[:5:]
print(list6)

list7 = list1[::4]
print(list7)

当起始索引大于结束索引时，步长必须为负数，否则结果是空列表

list8 = list1[7:2:-1]
print(list8)

特殊情况: 当同时省略起始索引和结束索引时，如果步长为负数，那Python会自动对调起始索引和结束索引

list9 = list1[::-1]
print(list9)

对元组进行切片

tuple1 = (10,20,30,40,50)
tuple2 = tuple1[0:5:1]
print(tuple2)

对字符串进行切片

msg1 = 'welcome to atguigu'
msg2 = msg1[0:10:1]
print(msg2)

序列的其他操作

相加

心血列 = 序列1 + 序列2
两个同类型的序列才能相加(字符串+字符串、列表+列表、元组+元组)
列表相加

list1 = [10,20,30,40]
list2 = [50,60,70,80]
list3 = list1 + list2
print(list3)

元组相加

tuple1 = (10,20,30,40)
tuple2 = (50,60,70,80)
tuple3 = tuple1 + tuple2
print(tuple3)

字符串相加

msg1 = 'hello'
msg2 = 'world'
msg3 = msg1 + msg2
print(msg3)

相乘

新序列 = 序列 * n

注意: n必须是整数，不能是浮点数

list1 = [10,20,30,40]
list2 = list1 * 3

print(list2)

元组相乘

tuple1 = (10,20,30,40)
tuple2 = tuple1 * 3

print(tuple2)

字符串相乘

msg1 = 'hello'
msg2 = msg1 * 3

print(msg2)