python基础(一)

小李子-_-

已于 2023-11-11 17:41:41 修改

阅读量96

点赞数

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

于 2023-11-07 11:47:39 首次发布

本文链接：https://blog.csdn.net/m0_46610658/article/details/134260363

版权

python 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

学习笔记相关视频链接：【黑马程序员python教程，8天python从入门到精通，学python看这套就够了】 https://www.bilibili.com/video/BV1qW4y1a7fU/?share_source=copy_web&vd_source=f43a6be454238fc9f46bff4a629369aa

一. 基本数据类型

python中常用的6中数据类型

1.1 数字

字面量就是在代码中，写下来的固定值。像整数1、2,、3，浮点数1.1、2.2、3.3都是字面量。数字主要包括整数、浮点数、复数和布尔，说一下布尔(bool)为什么归为数字(Number)类型。

print(True+1)
print(False+1)
"""
输出：
2
1
"""

从上面代码可以看出，True在进行相加运算时表示为1，False表示为0。因此把布尔类型的数据(True和False)归纳为数字类型。整数、浮点数和复数就不再介绍了。

1.2 字符串

字符串有如下三种定义方式：单引号定义、双引号定义和三引号定义。其中三引号可用来定义字符串，也可以作为多行注释的声明。大家在定义字符串的时候建议使用单引号或者双引号。

str1 = 'hello-world'  # 1.单引号定义法
str2 = "hello-world"  # 2.双引号定义法
str3 = """hello-world"""  # 3.三引号定义法

字符串的引号嵌套：如果定义的字符串本身包含：单引号、双引号，解决方案如下：

str1 = '"hello" "world"'  # 1.单引号可以内嵌双引号
str2 = "'hello' 'world'"  # 2.双引号可以内嵌单引号
str3 = '"""hello""" """world"""'  # 3.单引号可以内嵌三引号
str4 = "\"hello\" \"world\""  # 4.使用转义字符(\)来将引号解除效用,变成普通字符串

字符串的拼接：使用"+"完成拼接

str1 = "hello"
str2 = "world"
str3 = str1+str2
print(str3)
print(str1+"world")
print("hello"+"world")
"""
输出：
helloworld
helloworld
helloworld
"""

字符串的格式化：字符串和数字不能进行直接拼接，字符串格式化可以解决该问题。

str1 = "age:"+16  # 直接拼接会出错
print(str1)
"""
TypeError: can only concatenate str (not "int") to str
"""

(1)字符串格式化的第一种方式

name = "小明"
age = 16
str1 = "我是: %s" % name
str2 = "年龄: %d" % age
str3 = "我是: %s, 年龄: %d" % (name, age)  # 多个变量占位,需要用括号把变量括起来,并按照占位的顺序填入
print(str1)
print(str2)
print(str3)
"""
输出：
我是: 小明
年龄: 16
我是: 小明, 年龄: 16
"""

其中，“%“表示我要占位；“s"表示将字符串放在占位的地方；“d"表示将整数放在占位的地方，即我先占个位置，等会有个变量过来，我要把它变成字符串或者整数放到占位的位置。注意：当变量为整数时，也可以使用占位符”%s”；但变量为字符串时，不能使用占位符”%d”。这是因为：整数16你可以看成是一个字符串"16"，但字符串"小明"你没办法看成是整数啊。在进行强制类型转换时，任何一个数字都可以通过str()转换为字符串，但字符串通过int()转为整数时存在限制条件(必须为整数字符串)。

name = "小明"
age = 16
str1 = "年龄: %s" % age
# str2 = "我是: %d" % name  # 会出错--> TypeError: %d format: a number is required, not str
print(str1)
"""
输出：
年龄: 16
"""

python中常见的数据类型占位符
字符串格式化的精度控制(针对于整数和浮点数)

num1 = 560
num2 = 56.34
print("整数的宽度设置为5:%5d" % num1)
print("小数的宽度设置为8,小数点精度设置为3:%8.3f" % num2)
print("仅设置小数点精度为3,不对宽度加以限制:%.3f" % num2)
"""
输出：
整数的宽度设置为5:  560
小数的宽度设置为8,小数点精度设置为3:  56.340
仅设置小数点精度为3,不对宽度加以限制:56.340
"""

(2)字符串格式化的第二种方式：通过语法f"内容{变量}"的格式来快速格式化。

name = "小明"
age = 16
print(f"我是{name},年龄:{age}")
msg = f"我是{name},年龄:{age}"  # 也可以将格式化后的信息存放在变量中
print(msg)
"""
输出：
我是小明,年龄:16
我是小明,年龄:16
"""

再次认识字符串
(1)尽管字符串看起来并不像列表、元组那样，一眼看上去就是存放了许多数据的容器，但不可否认字符串是数据容器。只不过字符串是存储字符的容器，一个字符串可以存放任意数量的字符，如下所示。

(2)字符串的下标(索引)：和其它容器如：列表、元组一样，字符串也可以通过下标进行访问。从前向后：下标从0开始；从后向前：下标从-1开始。

str1 = "hello"
print(str1[0])  # 结果：h
print(str1[-1]) # 结果：o

(3)字符串常用的方法

str1 = " hello-world \n"
print(str1.index("-"))  # 结果: 6
print(str1.replace("-", "+"))  # 结果: " hello+world \n"
print(str1.split("-"))  # 结果: [' hello', 'world \n']
print(str1.strip())  # 结果: "hello-world"
print(str1.count("l"))  # 结果: 3
print(len(str1))  # 结果: 14

(4) 作为数据容器，字符串有如下特点：

只可以存储字符串；
长度任意(取决于内存大小)
支持下标索引
允许重复字符串存在
不可以修改(同元组一样，字符串是一个无法修改的数据容器，不能进行增加或删除元素等)
支持for循环

字符串的比较：在程序中，字符串所用的字符如：大小写因为字母、数字、特殊字符都有其对应的ASCII码表值。每一个字符都能对应上一个数字的ASCII码值，因此字符串可根据字符对应的ASCII码值进行比较。

1.3 列表

列表内每一个数据都被称为元素，每个元素之间用",“逗号隔开，并使用”[ ]"作为列表的标识，其定义如下代码所示。

# 定义一个列表,并赋值给变量list1
list1 = [1, 2, 3, 4, 5]
# 定义空列表
list2 = []
list3 = list()

列表的下标索引

（1）正向下标索引

（2）反向下标索引

name_list = ["ZS", "LS", "WW", "ML"]
print(name_list[1])  # 结果:"LS"
print(name_list[-3])  # 结果:"LS"

列表常用的方法

age_list = [25, 30, 22]
print(age_list.index(30))  # 结果: 1

age_list[0] = 20  # 修改指定位置(索引)的元素值
print(age_list)  # 结果: [20, 30, 22]

age_list.insert(1, 27)  # 在指定的下标位置插入元素
print(age_list)  # 结果: [20, 27, 30, 22]

age_list.append(35)  # 将指定元素追加到列表尾部
print(age_list)  # 结果: [20, 27, 30, 22, 35]

age_list.extend([10, 11, 12])  # 将数据容器中的元素取出,然后依次追加到列表尾部.
print(age_list)  # 结果: [20, 27, 30, 22, 35, 10, 11, 12]

del age_list[-1]  # 删除最后一个元素
age_list.pop(-1)  # 删除最后一个元素
print(age_list)   # 结果: [20, 27, 30, 22, 35, 10]

age_list.remove(10)
print(age_list)  # 结果: [20, 27, 30, 22, 35]

print(len(age_list))  # 列表长度为: 5
print(age_list.count(20))  # 元素20在列表中的数量为1

age_list.clear()
print(age_list)  # 结果: []

列表解析：就是将for循环和创建新元素的代码合并成一行，并自动附加新元素。要使用列表解析这种语法，首先在"=“号左边指定一个描述性的列表名，如"my_list2”；然后，在方括号内部定义一个表达式，用于生成你要存储在列表中的值，如"value*2"所示；最后，编写一个for循环用于给表达式提供值。注意：这里的for循环语句末尾没有添加冒号。

my_list1 = []
for value in range(10):
    my_list1.append(value)
print(f"my_list1:{my_list1}") # 需要三行代码才能生成有元素的列表my_list1

my_list2 = [value*2 for value in range(10)]  # 只需编写一行代码就能生成有元素的列表my_list2
print(f"2*my_list1:{my_list2}")
"""
输出结果：
my_list1:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2*my_list1:[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
"""

列表的特点

可以容纳多个元素
可以存储不同类型的元素(混装)
数据是有序存储的(有下标序号)
允许重复的数据存在
可以修改(增加或者删除元素等)

1.4 元组

列表是可以修改的，如果想要传递的信息不被篡改，可以使用元组来存储数据。元组同列表一样，都可以存储多个不同类型的元素，但元组一旦定义完成，就无法修改。元组的定义如下代码所示，注意：当元组只有一个元素时，这个元素后面需要添加一个逗号。

# 定义一个元组,并赋值给变量tuple1
tuple1 = (1, 2, 3)
# 定义空元组
tuple2 = ()
tuple3 = tuple()

元组的相关方法

data_tuple = (1, 2, 3, 1, 1, 4)
print(data_tuple.index(1))  # 结果: 0
print(data_tuple.count(1))  # 结果: 3
print(len(data_tuple))  # 结果: 6

元组的特点

和列表基本相同(有序、任意数量元素、允许元素重复)，唯一不同点在于不可修改
支持for循环

1.5 集合

集合最主要的特点就是：使用"{ }"作为标识、不支持元素重复(自带去重功能)、并且元素无序，其定义如下代码所示。

# 定义一个集合,并赋值给变量set1
set1 = {1, 2, 3, 4}
# 定义空集合
set2 = set()

集合的相关方法

my_set = {"hello", "world"}

my_set.add("China")  # 将指定元素添加到集合中
print(my_set)  # 结果: {'hello', 'China', 'world'}

my_set.remove("world")  # 将指定元素从集合内删除
print(my_set)  # {'hello', 'China'}

my_set.clear()  # 清空集合
print(my_set)  # 结果: set()


set1 = {1, 2, 3}
set2 = {3, 4, 5}
set3 = set1.difference(set2)  # set1有而set2没有的,得到一个新集合,原来的集合set1和set2不变
print(set1)  # 结果: {1, 2, 3}
print(set3)  # 结果: {1, 2}
set1.difference_update(set2)  # 在set1内删除和set2相同的元素
print(set1)  # 结果: {1, 2}
set4 = set1.union(set2)  # set1和set2合并,得到二者的并集
print(set4)  # 结果: {1, 2, 3, 4, 5}

集合的特点

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

1.6 字典

字典同集合一样，使用"{ }"作为标识，只不过字典内部存储的元素是一个个键值对(key：value，key不可以为字典)，定义如下代码所示。

# 定义一个字典,并赋值给变量my_dict
my_dict = {"A": 1, "b": 2}
# 定义空字典
my_dict = {}
my_dict = dict()

字典的相关方法

my_dict = {"A": 1, "B": 2}
print(my_dict["A"])  # 结果: 1
my_dict["C"] = 3
print(my_dict)  # 结果: {'A': 1, 'B': 2, 'C': 3}
my_dict["B"] = 3  # 字典的key不可以重复,所以添加已存在的key相当于更新value值
print(my_dict)  # 结果: {'A': 1, 'B': 3, 'C': 3}
value = my_dict.pop("C")  # 获取指定key对应的value,并删除该key和value
print(value)  # 结果: 3
print(my_dict)  # 结果: {'A': 1, 'B': 3}
keys = my_dict.keys()  # 获取字典中全部的key
print(keys)  # 结果: dict_keys(['A', 'B'])
print(my_dict.values())  # 获取字典中全部的value,结果: dict_values([1, 3])

字典的items()、keys()、values()方法

items()方法：可用于遍历字典中的所有键-值对；
keys()方法：可用于遍历字典中的所有键；
values()方法：可用于遍历字典中的所有值。

my_dict = {"name": "张三", "age": 15, "gender": "male"}
# 1.使用items()方法遍历字典中的所有键-值对
for key, value in my_dict.items():
    # 这里声明的变量key和value用于存储键-值对中的键和值。
    print(f"key: {key},value:{value}")

# 2.使用keys()方法遍历字典中的所有键；
for key in my_dict.keys():
    print(f"key:{key}")

# 3.使用values()方法遍历字典中的所有值。
for value in my_dict.values():
    print(f"value:{value}")
"""
输出：
key: name,value:张三
key: age,value:15
key: gender,value:male
key:name
key:age
key:gender
value:张三
value:15
value:male
"""

字典的特点

可以容纳多个、不同类型的数据
每个数据是键值对(key：value)
可通过key获取到value，key不可重复(key重复会覆盖value)
不支持下标索引
可以修改(增加或删除元素)
支持for循环，不支持while循环

1.7 数据容器的分类和对比

数据容器分类
python中的数据容器是指：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素可以是任意类型的数据，如字符串、数字等。数据容器根据不同的特点(如：是否支持重复元素、是否可以修改、是否有序等)可分为5类，分别是：列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)。
数据容器特点对比
数据容器的通用操作

遍历：这5类数据容器(列表、元组、字符串、集合、字典)均支持for循环遍历，但列表、元组、字符串支持while循环，集合和字典不支持while循环(因为无法下标索引)。
统计功能：这5类数据容器除了具有遍历这个共性外，还支持len(容器)、max(容器)、min(容器)的统计功能。
类型转换功能：list(容器)–>将给定容器转为列表；str(容器)–>将给定容器转为字符串；tuple(容器)–>将给定容器转为元组；set(容器)–>将给定容器转为集合。
排序功能：sorted(容器,[reverse=True])–>将给定容器进行排序。

1.8 数据容器的切片操作

1.序列

2. 切片操作

二. 判断语句和循环语句

2.1 判断语句

布尔类型(bool)的字面量为True表示真，为False表示假。布尔类型不仅可以自行定义(flag = True 或 flag = False)，还可以通过使用比较运算符进行比较运算来得到。常见的比较运算符如下图所示。
if 判断语句：判断语句的核心是一个值为"True"或"False"的条件表达式，条件表达式的值如果为True，就会执行if语句所包含的代码块；如果为False，就会忽略这些代码，也就是不执行这些代码块。

if 要判断的条件(条件表达式):
	条件成立时,需要做的事情
例子:
num = 2
if num>1:
	print("hello world")

检查多个条件：对于具有多个条件的表达式，可使用关键字and 或者 or将多个条件整合在一起。如下代码所示，对于关键字and，所有条件都为True时，整体才为True，否则就为False；对于关键字or，至少有一个条件为True，整体就为True，只有当所有条件为False时，整体才为False。

age0 = 22
age1 = 23
print(age0 > 20 and age1 > 22)  # 结果: True
print(age0 > 20 and age1 > 24)  # 结果: False
print(age0 > 20 or age1 > 24)  # 结果: True
print(age0 > 23 or age1 > 24)  # 结果: False

检查特定值是否包含或不包含在列表中：使用关键字in来判断特定的值是否包含在列表中，使用关键字not in来确定特定的值未包含在列表中。

name_list = ["张三", "李四"]
print("张三" in name_list)  # 结果: True
print("王五" in name_list)  # 结果: False
print("张三" not in name_list)  # 结果: False
print("王五" not in name_list)  # 结果: True

# 对于元组和集合可同样使用"in"和"not in"来检查特定值是否包含或不包含在列表中

if else判断语句：else后面不需要判断条件。

if 要判断的条件:
	条件成立时,需要做的事情
else:
	条件不成立时,需要做的事情
例子:
num = 2
if num>1:
	print("hello python")
else:
	print("hello java")

if elif else判断语句

if 要判断的条件1:
	条件1成立时,需要做的事情
elif 要判断的条件2:
	条件2成立时,需要做的事情
	......
elif 要判断的条件N:
	条件N成立时,需要做的事情
else:
	所有条件都不成立时,需要做的事情
例子:
grade = 85
if grade>90:
	print("A")
elif grade>80:
	print("B")
elif grade>70:
	print("C")
else:
	print("D")

2.2 循环语句

while循环语句：只要条件满足，会无限循环执行。while循环语句注意事项："条件"需要提供布尔类型结果，True继续、False停止。

while 条件:
	条件满足时需要做的事情

for循环语句(可以理解为遍历)：待处理数据指的是序列类型数据，序列类型数据是指其内容可以一个个依次取出，包括：字符串、列表和元组等。

for 临时变量 in 待处理数据:
	循环满足条件时执行的代码
例子：
for i in "hello-world":
	print(i)

continue语句和break语句

三. 杂七杂八

单行注释：以"#“开头，”#"右边的所有文字当作说明，而不是真正执行的程序，起辅助作用。

# 我是单行注释
print("hello python")

多行注释：以一对三个双引号引起来解释一段代码的作用和使用方法。

"""
计算两数之和
参数a:传递的参数
参数b:传递的参数
"""
def sum(a, b):
	return a+b

变量
标识符：在python程序中，我们可以给变量、方法和类起名字，这些名字我们把它称为标识符。标识符的命名规则为：内容限定、大小写敏感、不可以使用关键字。其中，内容限定是指在标识符命名中，只允许出现英文、中文、数字、下划线，其余任何内容都不被允许出现，且数字不可以作为标识符的开头，不推荐使用中文。变量的命名规范：见名知意、下划线命名法(多个单词组合成变量名，要使用下划线做分隔符)、英文字母全小写。
运算符