Python基础知识

Dream寻糜

已于 2023-09-05 16:05:07 修改

阅读量91

点赞数

分类专栏： python 文章标签： python

于 2023-08-31 15:47:01 首次发布

本文链接：https://blog.csdn.net/qq_42523200/article/details/132604656

版权

python 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1. 简单数据类型

1.1 变量

msg = 'Hello,World !'
print(msg)

1.1.1 变量的命名规则

变量名只能包含字母、数字和下划线。
不要将Python关键字和函数名用作变量名，比如 print 。
中文也可以作为变量，建议避免使用。
变量名应该简短且富于描述性 —— 建议

1.2 字符串str

所谓字符串，就是由零个或多个字符组成的有限序列。字符串是使用最广泛的基础数据类型。在Python 中，用双引号 “” 或者单引号 ‘’ 包围起来的都是字符串，但不能是一个单引号和一个双引号：

1.2.1 转义符

转义字符	说明
\n	换行符，将光标位置移到下一行开头。
\r	回车符，将光标位置移到本行开头。
\t	水平制表符，也即 Tab 键，一般相当于四个空格。
\a	蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。
\b	退格(Backspace)，将光标位置移到前一列。
\	反斜线
’	单引号
"	双引号
\	在字符串行尾的续行符，即一行未完，转到下一行继续写。

1.2.2 常见字符串操作

前面四个要牢记！！！

string = '   我是一位数据分析师 ,我是物理学者    '
string.replace('数据分析师', '物理学者')  # 替换字符串，帅哥替换从美女
string.strip()  # 去除左右空格
string.split('， ')  # 拆分字符串，返回list
string.find('， ')  # 查找字符串，返回索引号
string = "I'am woodman"
print(string.upper())  # 将字符串全部转为大写
print(string.lower())  # 将字符串全部转为小写
print(string.title())  # 将字符串单词的第一个字母转为大写，其它字母小写

1.3 数字

1.3.1 常见数值操作

abs(-5)  # 取绝对值。5
round(1.234)  # 四舍五入，取整，1
round(1.234, 2)  # 四舍五入，保留2位小数，1.23
max(1, 2, 3, 4, 5)  # 最大值，5
min(1, 3, 5)  # 最小值，1

int(12.3)  # 转换为整数，12
float('12.3')  # 转换为浮点数，12.3
# math数学运算库 —— Python标准库
import math

math.pi  # π
math.e  # 自然常数
math.ceil(4.1)  # 5, 向上取整
math.floor(4.1)  # 4, 向下取整
math.fabs(-3)  # 3, 绝对值
math.fsum((-1, 1))  # 0, 求和，返回值为浮点数
math.isnan(math.nan)  # True, 如果是NaN, 返回True
math.trunc(3.1)  # 3, 截取数值的整数部分

1.3.1 随机数

在实际工作中，对于数值我们还需要进行随机数操作，此时就需要用到内置模块 random 。注意：这里的随机数本质是伪随机数。

import random  # 导入模块

random.randrange(10)  # 随机抽取一个0到10之间的整数
random.randrange(0, 10, 2)  # 先模拟产生一个0到10(不含10)，步长为2的序列，再随机抽取一个整数 random.randint(0, 10) # 随机抽取一个0到10之间的整数
a = [1, 2, 3, 4, 5]
random.choice(a)  # 从序列中随机抽取一个元素
random.sample(a, 2)  # 从序列中随机抽取k个元素，无重复的随机抽样，返回子集
random.random()  # 随机抽取一个0到1之间的浮点数

2. 列表

2.1 列表是什么

Python中，用方括号[]表示列表，用逗号(,)分割其中的元素

2.1.1 定义列表

bikes = ['飞鸽', '凤凰', '永久']  # [item1, item2, item3]
foo = ['飞鸽', 23, True]  # 列表允许保存不同的类型的变量，但通常不推荐
ages = [18, 18, 20]  # 列表可以有“重复”的元素
print(f'我有一辆{bikes[1]}牌自行车')

2.1.2 修改列表


bikes.append('龙翔')  # 添加到列表的末尾
bikes.insert(4, '飞舞')  # 在指定索引前插入元素
bikes.pop()  # 删除列表最后一个元素,并返回该元素。
bikes.remove('永久')  # 根据值来删除元素，删除首次匹配到的；如果匹配到多个元素，仅仅删除第一个；如果没有匹配到则触发异常
del bikes[2]    # 删除（释放）指定的对象——不仅仅针对列表
print(bikes)

2.1.3 列表排序

bikes = ['飞鸽', '凤凰', '永久', '飞翔']  # [item1, item2, item3]
bikes_2 = ['feige', 'fenghuang', 'yongjiu', 'feixiang']
bikes.sort()	# 排序，默认排序为升序，针对中文不生效
bikes_2.sort()  
bikes_2.sort(reverse=True)  # 倒序
sorted(bikes_2, reverse=True)    # 临时排序，不影响原始数据的顺序，reverse=True为降序
new_list = sorted('refuse', reverse=False)  # 临时排序_2，reverse=False为升序
bikes_2.reverse()   # 列表直接反转，不涉及排序，改变的是原始数据
print(bikes, bikes_2, new_list)

2.2 用for循环遍历列表

bikes = ['飞鸽', '凤凰', '永久', '飞翔']  # [item1, item2, item3]
for bike in bikes:
    print(f'我的自行车是{bike}牌子的。')
print('\n循环结束')

# 列表中数值累加
numbers = [3, 9, 8, 5]
sum_value = 0
for n in numbers:
    sum_value = sum_value + n
print(f'sum_value = {sum_value}')

2.3 数值列表

2.3.1 range（）函数

可以直接使用for遍历；而且可以直接访问范围的值

numbers = range(1, 1001)
list(numbers)   # 将range对象强制转换为List对象
list(range(10, 20))     # 从10开始到19的数组,默认步长为1
list(range(10, 20, 2))  # 从10开始步长为2的数组

practice

# 1到1000求和
numbers = range(1, 1001)
sum_value = 0
for n in numbers:
    sum_value = sum_value + n
print(sum_value)

# 1到1000之间的奇数求和
numbers = range(1, 1001, 2)
sum_value = 0
for n in numbers:
    sum_value += n	# sum_value = sum_value + n和sum_value += n相等
print(sum_value)

# 创建一个列表，其中包含前10整数的平方（使用for循环和append（）方法）
lists = []
for i in range(1, 11):
    lists.append(i**2)
print(lists)

2.3.2 数值列表的简单统计

digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a = min(digits) 	# 数组最小值
b = max(digits) 	# 数组最大值
c = sum(digits) 	# 数组求和

2.4列表生成器

列表解析式将for循环和创建新元素的代码合并成一行，并自动附加新元素

格式：[表达式 for循环] 过滤条件

numbers = [i**2 for i in list(range(10))]
print(numbers)
# 上与下功能相同，但上方代码更为简洁
num_list = []
for i in range(10):
    num_list.append(i**2)
print(num_list)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

practice

'获取文本中所有单词的第一个字符'
text = "My house is full od flower"
words = [word[0] for word in text.split()]   # text.split()将字符串分割为单词列表，默认分隔符为空字符
print(words)

['M', 'h', 'i', 'f', 'o', 'f']

'嵌套的表达式生成器'
cross_list = []
s1 = 'ABC'
s2 = 'XYZ'
var = [m + n for m in s1 for n in s2]
print(var)

['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

2.5 切片

start_index：表示起始索引(包含该索引对应值)；该参数省略时，表示从对象“端点”开始取值，至于是从“起点”还是从“终点”开始，则由step参数的正负决定， step为正从“起点”开始，为负从“终点”开始。
end_index：表示终止索引(不包含该索引对应值)；该参数省略时，表示一直取到数据“端点”，至于是到“起点”还是到“终点”，同样由step参数的正负决定， step为正时直到“终点”，为负时直到 “起点”。
step：正负数均可，其绝对值大小决定了切取数据时的‘‘步长”，而正负号决定了“切取方向”，正表示“从左往右”取值，负表示“从右往左”取值。当step省略时，默认为1，即从左往右以步长1取值

digits = list(range(0, 10))
s1 = digits[0:3]
s2 = digits[:3]     # 索引0-2，开头不写的时候，默认值为0
s3 = digits[3:]     # 不写结尾的时候，默认索引到结束
s4 = digits[::2]
s5 = digits[::-1]
print(f'{s1}, \n{s2}, \n{s3}, \n{s4}, \n{s5}')

[0, 1, 2],
[0, 1, 2],
[3, 4, 5, 6, 7, 8, 9],
[0, 2, 4, 6, 8],
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

注意：当起索引超出有效索引范围时，切片操作不会抛出异常，而是进行截断

2.5.1 复制列表

# 共享内存
# 当新赋值列表与旧列表关联时，新列表的变化也会影响旧列表(直接‘=’赋值相当于给列表起了两个名字，两列表相互影响)
digits = [1, 3, 5, 9]
new_digits = digits
print(new_digits)
print(digits)

new_digits.append(11)
print(new_digits)
print(digits)

[1, 3, 5, 9]
[1, 3, 5, 9]
[1, 3, 5, 9, 11]
[1, 3, 5, 9, 11]

# 想要完美的复制一份列表，就需要两个列表各自独立(切片相当于在原列表的基础上返回新的列表，两者相互不影响)
digits = [1, 3, 5, 9]
new_digits = digits[:]
print(new_digits)
print(digits)

new_digits.append(11)
print(new_digits)
print(digits)

[1, 3, 5, 9]
[1, 3, 5, 9]
[1, 3, 5, 9, 11]
[1, 3, 5, 9]

2.6 元组

注意：如果只有一个元素的元组，定义时候需要加一个逗号，否则定义为整数型

t = (1)    # 如果只有一个元素的元组，定义时候需要加一个逗号
print(type(t))

<class 'int'>

t = (1,)   
print(type(t))

<class 'tuple'>

如果元组中的元素是容器类对象，如果该对象本身可以修改，可以修改容器对象中的内容

t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'
print(t)

('a', 'b', ['X', 'Y'])

在这里插入图片描述

practice

# 想出6种食物，放到元组中。转化为列表后添加一位食物，再转化为元组
foods = ('豆浆', '油条', '豆腐脑', '咖啡', '面包', '法式焗蜗牛')
new_foods = list(foods)
new_foods.append('肠粉')
new_foods_1 = tuple(new_foods)
index = 0
print(type(new_foods_1))
print(f'今日营养早餐有:\n')
for f in new_foods_1:
    index += 1
    print(f'{index}:{f}')

3. IF 语句

3.1 一个简单的例子

# 如果是宝马的话全大写方式打印，否则以首字母大写的方式打印
cars = ['audi', 'bmw', 'toyota', 'subaru']

for car in cars:
    if car == 'bmw':
        print(car.upper())
    else:
        print(car.title())

Audi
BMW
Toyota
Subaru

3.2 条件测试（布尔表达式或逻辑表达式）

if语句的核心是条件测试，结果为逻辑值的表达式

检查是否相等时需要考虑大小写是否相同
and：多个条件都是真True，最终结果都是True，换言之，只要有一个是False，整个结果都是False
or：多个条件只要有一个是真True，最终结果都是True。
not：取反
不加括号的情况下，优先级：not > and > or
用‘==’判断是否相等，用‘in’判断是否在列表中

3.2.1 短路表达式

# 在Python中，下列值被认为是False
a = 0    # 数值型的0
s = ''  # 字符型的空字符
arr = []    # 空列表

if arr:
    print(0)
else:
    print(1)

1

print(10 and 5 or 4)    # True and True or True
print(10 and 0 and 2)   # True and False and True
print(10 or 0 and 2)    # True or False and True

5 0 10

3.3 if语句

3.3.1 最简单的if语句

if 条件1：
	pass
elif 条件2:
    pass
else 条件:
	pass

practice

# 根据输入年龄，判断游乐场应该收取的票价
age = input('请输入您的年龄')  # input返回为str类型，进行数字比较时需将返回值转换为int类型
age = int(age)
price = 100
if 0 < age < 12:
    print('免费通过')
elif 12 <= age < 50:
    print(f'请支付全额票价,{price}元')
elif 50 <= age < 70:
    print(f'请支付50%票价,{int(price/2)}元')
elif 70 <= age < 120:
    print('免费通过')
else:
    print('请输入正确年龄')

# 判断登录用户是否在用户列表内，站点跟不同的用户打招呼
Names = input('请输入您的用户名：')
Name_list = ['admin', 'wlw', 'yfy', 'zjl']	# 创建一个包含若干用户的列表
Name_list_1 = Name_list[1::]
print(Name_list_1)
if not Name_list_1:   # 或Name_list_1 == []表示列表为空；
    print('我们需要拉一批客户进来')
else:
    if Names == 'admin':
        print('您好，管理员，需要看一下运行报告吗？')
    elif Names in Name_list_1:
        print(f'您好{Names}，欢迎再次光临')
    else:
        print('该用户不存在')

4. 字典 dict和集合set

将信息关联起来,本质上是一系列键值对。语法格式：{键1:值1, 键2:值2, …}

比如有份成绩表数据，语文： 79，数学： 80，英语： 92，这组数据看上去像两个列表，但这两个列表的元素之间有一定的关联关系。如果单纯使用两个列表来保存这组数据，则无法记录两组数据之间的关联关系。
为此 Python 提供了字典，字典相当于保存了两组数据，其中一组数据是关键数据，被称为 key；另一组数据可通过 key 来访问，被称为 value。字典可存储的信息量几乎不受限制，而且具有极快的查找速度。
形象地看，字典中 key 和 value 的关联关系如图 1 所示：

在这里插入图片描述

注意：由于字典中的 key 是非常关键的数据，而且程序需要通过 key 来访问 value，因此字典中的的Key不允许重复

stu_a = {'id': 123, 'name': '王大锤', 'age': 22, 'chinese': 90, 'math': 80}  # 定义字典
print(f"尊敬的{stu_a['name']}家长，本次考试成绩如下：\nchinese:{stu_a['chinese']} \nmath:{stu_a['math']} ")

尊敬的王大锤家长，本次考试成绩如下： chinese:90
math:80

如果成绩和得分是两个列表，可以使用 zip() 函数来顺序对应合并为key-value 对

**zip()**函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的 zip 对象，可以使用 list() 转换来输出列表。如果各个迭代器的元素个数不一致，则 zip 返回列表长度与最短的对象相同

lesson_list = ['语文', '数学', '英语']
score_list = [89, 92, 93]

score_item_list = list(zip(lesson_list,score_list))
score = dict(score_item_list)

print(score)

{'语文': 89, '数学': 92, '英语': 93}

4.1.1 添加/修改键值对

stu_a['age'] = 21   # 修改 —— 当Key存在的时候
stu_a['English'] = 100  # 新增 —— 当Key不存在的时候，就是新增
stu_a = {}  # 初始化，空的字典

4.1.2 删除字典中的对象（键值对）

stu_a['id'] = None  # None是python中的一种数据类型，含义是未定义
del stu_a['name']   # 删除指定键值对：需要指定字典中的Key

4.1.3 使用get（）访问字典

stu_a.get('English', 'NotExist')    # 第二个参数：当Key不存在的时候，返回的默认值为None

该方法并不改变字典本身，只用于访问字典时不会报错

4.2 遍历字典

# 默认情况下，遍历字典，返回的元素是Key
for item in stu_a:
    print(item, end=' ') 	# end= ''将整个for循环的输出在一行中

id name age chinese math

# 遍历键值对 
for item in stu_a.items():
    print(item, end=' ')

('id', 123) ('name', '王大锤') ('age', 22) ('chinese', 90) ('math', 80)

for k, v in stu_a.items():
    print(f"{k} = {v}")

id = 123
name = 王大锤
age = 22
chinese = 90
math = 80

4.3 集合 set

集合：无序的不重复的元素序列，退化的字典，可以看作没有Key的字典

可以使用大括号 **{}**或者 set() 函数创建集合，

注意：创建一个空集合必须用 set\而不是{}，因为{}是用来创建一个空字典。

s1 = {1, 2, 3, 4, 5, 6, 7, 8, 9}
s2 = {'a', 'b', 'c'}
s3 = ()

4.4 嵌套

字典键值对的value可以是任意类型，换言之可以是字典也可以是列表；同样的，列表的元素也可以是任意类型，如列表、字典等。这就意味着列表和字典可以互相嵌套。

由字典组成的列表：

stu1 = {'name': '猪小明 ', 'age': 8, 'city': '广州'}
stu2 = {'name': '毛台 ', 'age': 37, 'city': '成都'}
stu3 = {'name': '闰土', 'age': 29, 'city': '乌鲁木齐'}

team1 = [stu1, stu2, stu3] # 列表中的元素是字典
for stu in team1:
	print(stu)

字典中的列表：

train = {
    'city': '广州 ',
    'lessons': ['Java', 'Python', 'CSS', 'Tableau']
}
print('培训地点： ')
print(f"\t{train['city']}")

print('培训课程:')
for lesson in train['lessons']:
    print(f'\t', lesson)

培训地点：
广州
培训课程:
Java
Python
CSS
Tableau

字典中的字典：

students = {
    'name': '王大锤',
    'contact': {
        'email': 'wdc@china.com',
        'tel': 1234567
    },
    'name': '赵铁棍',
    'contact': {
        'email': 'ztg@abc.com',
        'tel': 7654321
    }
}

practice

user1 = {
    '姓名': '王大锤',
    '电话号码': '13312354351',
    '城市': '西宁'
}

user2 = {
    '姓名': '赵铁棍',
    '电话号码': '13053180377',
    '城市': '咸阳'
}

user3 = {
    '姓名': '猪小明',
    '电话号码': '13753184626',
    '城市': '广州'
}

relations = [user1, user2, user3]

for relation in relations:
    print(f"{relation['姓名']}({relation['城市']}):{relation['电话号码']}")
print(user3['城市'])

王大锤(西宁):13312354351
赵铁棍(咸阳):13053180377
猪小明(广州):13753184626
广州

5. 用户输入和 while 循环

5.1 函数 input()

程序暂停，等待并接受用户输入

number = int(input('请输入一个整数：'))

if number % 2 == 0:
    print('该数字为偶数')
elif  number % 2 == 1:
    print('该数字为奇数')		# 程序不完整，当用户不输入数字时还需更多操作进行验证

5.2 while 循环

# 要求用户输入年龄后如果为正整数，输出年龄并继续游戏，如果为负数，游戏结束。
age = int(input('请输入你的年龄，（负数推出）'))
while age > 0:
    print('您的年龄是：' + str(age))
    age = int(input('请输入你的年龄，（负数推出）'))
print('游戏结束了')

# 要求用户输入年龄后如果为正整数，输出年龄并继续游戏，如果为负数，游戏结束。
is_go = True    # 逻辑变量以is或has开头
while is_go:
    age = int(input('输入你的年龄（整数），负数退出'))
    if age < 0:
        is_go = False
    print(f'你的年龄是{age}')
print('游戏结束了')

practice

# 猜数字
'''
1.随机生成1-100间的整数
2.用户输入猜测的数字
3.如果没有猜中，提示用户输入的数字大/小，并重新输入
4.猜中后提示用户猜中了，然后结束猜数字游戏
5.如果用户输入-1，也结束游戏
6.如果连续10次没有猜中，结束游戏'''
ran_number = random.randrange(1， 100)
number = int(input('请输入1-100之内的整数'))
is_right = True
i = 2
while is_right:
    if i <= 10:
        i += 1
        if number == -1:
            print('您结束了游戏')
            is_right = False
        elif number < ran_number:
            number = int(input('您猜测的数字偏小,请重新输入'))
        elif number > ran_number:
            number = int(input('您猜测的数字偏大,请重新输入'))
        else:
            print('您猜中啦！')
            is_right = False
    else:
        print(f'你已猜测超过{i}次，你失败啦！')
        is_right = False
print('游戏结束')

5.3 break 和 continue

break 既可用于while 也可用于 for 循环

如果你要立即退出 while 循环，不再运行循环体中余下的代码，也不管 while 后面跟的表达式是真是假，可以使用break语句。

比如下面一个餐馆点菜的程序：

prompt = '\n请输入您想吃的菜名(输入 quit 结束点菜)： '

while True:
    food = input(prompt)
    if food == 'quit':
        break
    else:
        print("我想吃：", food)

我们将True作为while的循环判断条件，因此这程序理论上会不断运行下去(在没有break语句的情况下)。

Python中使用 continue 会忽略余下的代码，并返回到循环的开头

break 强制结束循环； continue 强制开始循环。相同点是都不执行后续代码

num = 0
while num < 10:
    num += 1
    if num % 2 == 0:
        continue
    print(num)

5.4 循环嵌套

# 九九乘法表
row = 1
while row <= 9:
    col = 1
    while col <= row:
        print(f'{row}*{col} = {row* col}', end=' ')
        col += 1
    print('')
    row += 1

# 用for遍历列表实现九九乘法表
for row in range(1, 10):
    for col in range(1, row+1):		# range(1, row+1)中+1是因为不包含截至数字
        print(f'{col}*{row} = {row * col}', end='  ')
    print(' ')