安装-day1

Python基础语法及数据类型常用的方法（day2、day3）

1. 注释的基本使用

注释的使用：

  • 单行注释
    • 使用符号：# 注释的相关描述文字信息
    • 快捷键: Ctrl + /
  • 多行注释
    • 使用符号：""" 被多行注释的相关内容 """ or '''被多行注释的相关内容'''

2. 变量的定义和使用

变量的概念：

  • 变量就是用来存储数据（可以是不同类型）的 ，可以一直变化或者被覆盖

变量的数据类型：

  • 整数类型: int
  • 浮点数类型: float
  • 布尔类型: bool
  • 列表: list
  • 元组: tuple
  • 字典: dict
  • 字符串: str
  • 集合: set
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
# 如何查看变量的数据类型：使用type内建函数进行查看  
# 内建函数：实现某种特定功能就叫做函数，Python自带的函数叫做内建函数  
# print(), type()都是属于内建函数具有某种功能，输出功能，查看类型功能

# 整数类型  
num = 100  
# 浮点数类型  
num2 = 3.14  
print(type(num))   # <class 'int'> 代表整数类型  
print(type(num2))  # <class 'float'> 代表浮点数类型（小数类型）  

# 布尔类型  
# 是两个关键字分别是：True默认代表数字：1,和False默认代表数字：0  
# 关键字：Python中已经取好的变量名，就叫做关键字，也具备某种特殊的含义  
print(type(True))   # <class 'bool'>  
print(type(False))  # <class 'bool'>  
print(True + True)   # 2  
 
# 列表：[]  
# 列表中可以存放任何的数据类型  
list1 = [11, 12.34, False, True]  
print(len(list1))  # 4   
print(type(list1))  # <class 'list'>  

# 元组：()  
t1 = (1, 2, 3, 4)  
print(len(t1))  # 4  
print(type(t1))  # <class 'tuple'>  

# 元组()默认可以不写，如果数据与数据之间隔开，那么就是元组  
t2 = 6, 7, 8  
print(type(t2))  # <class 'tuple'>  

# 字典: {键:值}, 可以同时有多个键值对  
dict1 = {"name": "胡歌"}  
print(type(dict1))  # <class 'dict'>  

dict2 = {"name": "胡歌", "name2": "彭子晏", "name3": "阮经天"}  
print(len(dict2))  # 3:3组键值对  
print(type(dict2))  # <class 'dict'>  

# 集合: {数据1,数据2}  
# 特性: 自动去重，集合中没有重复的数据  
set1 = {1, 2, 3}  
print(type(set1))  # <class 'set'>  

# 字符串: '字符',"字符","""字符"""  
# 字符串含义: 用引号引起来的任何一串字符就叫做字符串  
name = '胡歌'  
name2 = "彭子晏"  
name3 = """阮经天"""  # 在定义变量的时候三个单/双引号表示字符串，不是多行注释  
 
print(len(name))    # 2  
print(len(name2))   # 3  
print(type(name))   # <class 'str'>

总结：

根据不同的数据类型会进行分类

  • 数字类型的数据：整数类型，浮点数类型，布尔类型
  • 非数字类型的数据：字符串，列表，元组，字典，集合

容器类型数据

  • 字符串，列表，元组，字典，集合

  • 容器类型里面的数据每个值叫做元素

  • 可以使用内建函数len()查看容器类型数据的长度，元素的个数

可变与不可变的数据类型进行分类

内建函数： 就是Python中已经定义好的功能，可以直接调用完成功能实现

内建函数的含义就是具备某种特定的功能

使用方式：通过内建函数名()

  • print()：输出功能
  • type()：查看变量的数据类型功能
  • len()：查看容器类型的数据个数

3. PyCharm中波浪线含义

波浪线颜色 含义 解决方法
黄色 代码不符合PEP8书写规范 使用快捷键 Ctrl + Alt + L
绿色 英文单词拼写错误 修正拼写错误
红色 语法错误 立即修正语法错误

4. 标识符的定义

标识符的含义： Python中所有的命名都叫做标识符

  • 变量名
  • 函数名
  • 类名
  • 对象名
  • 模块名
  • 包名
  • …

4.1 标识符的命名规则

  • 由数字、字母、下划线组成，不能以数字开头，不能是关键字
    • 关键字：Python中已经取好的名字就叫做关键字
    • 每个关键字都会有独特的含义
    • 在PyCharm中显示：橙色高亮
1
2
3
4
5
6
7
import keyword  

# 查看关键字列表  
print(keyword.kwlist)  
# ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']  

print(len(keyword.kwlist))  # 35
  • 区分大小写
  • 不建议使用不符合规范的名字

4.2 标识符命名建议

  • 见名知意：尽量使用英文单词（如姓名：name，年龄：age）
  • 小驼峰命名法：第一个单词首字母小写，后续单词首字母大写（如：myName）
  • 大驼峰命名法：每个单词首字母都大写（类名常用，如：FirstName）
  • 下划线命名法：单词间用下划线连接（如：user_name）

注意点：

  • 所有标识符命名唯一可以使用的符号就是 _ 下划线

5. 格式化输出

格式化输出的含义：

  • 按照指定的方式，拼接字符串新的内容进行输出
  • 当输出一个字符串的同时，结合变量一起输出

5.1 占位符格式化输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
name = "蔡徐坤"  
age = 18  
height = 1.78  

# 占位符类型：  
# %s - 字符串  %d - 整数  %f - 浮点数  
print('我的名字是：%s' % name)  
print('我今年：%d岁' % age)  

# 浮点数默认保留六位小数  
# %.2f 保留两位小数  
print('我的身高是：%.2f米' % height)  

# 多个变量同时输出  
print('我的名字是：%s，我今年：%d岁，我的身高是：%.2f米' % (name, age, height))

5.2 format函数格式化输出

1
2
3
4
5
6
7
8
9
10
name = "蔡徐坤"  
age = 18  
height = 1.78  

# 默认顺序  
print("我的名字是：{}，我今年：{}岁，我的身高是：{}米".format(name, age, height))  
 
# 简化
print(f"我的名字是：{name},我今年：{age},我的身高是：{height}")
print(F"我的名字是：{name},我今年：{age},我的身高是：{height}")

6. 标准输入

通过 input() 函数接收用户输入： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# input在没有收到数据之前，程序会挂起  
password = input("请输入你的密码：")  
print("您输入的密码是：", password)  
print(type(password))  # <class 'str'>  

# 注意：input获取的所有内容都会转为字符串  
num1 = input("请输入第一个数字：")  
num2 = input("请输入第二个数字：")  
print(f"相加结果为：{num1 + num2}")  # 字符串拼接（如：输入12和13得到"1213"）  

# 转换类型示例  
num1 = int(input("请输入第一个数字："))  
num2 = int(input("请输入第二个数字："))  
print(f"相加结果为：{num1 + num2}")  # 数值相加

总结：

  • 使用 input() 时程序会挂起，不按回车不会往下执行
  • 输入的所有数据都会转为字符串类型
  • 需要数值计算时需手动转换类型（如 int()）

7.字符串的索引和切片

字符串这种数据类型是属于有序的序列，构成字符串的每个数据叫做元素，每个元素具有索引（下标）

字符串通过索引取元素值，索引的概念就是每个元素的编号

通过索引提取元素单个值：

1
2
3
4
5
6
7
str1 = "qwer我是天秋老师!@#$ %^&ASDF"
# 查看字符串长度
print(len(str1)) # 22
# 通过字符串的索引获取元素值，索引开始值为：0
print(str1[1]) # w
# 元素的索引也可以是负数：-1代表最后一个元素
print(str1[-4]) # A

通过索引提取元素多个值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
str1 = "qwer我是天秋老师!@#$ %^&ASDF"
# 通过索引提取多个元素时，中介用冒号隔开，开始：结束
# 包含开始，不包含结束：左闭右开的区间
print(str1[0:6]) # qwer我是

# # 默认不写开始和结束，获取字符所有元素值
print(str1[:]) # qwer我是天秋老师!@#$ %^&ASDF
# # 只写开始，只写结束
print(str1[3:]) # r我是天秋老师!@#$ %^&ASDF
print(str1[:8]) # qwer我是天秋

# 使用负数索引提取元素值
# 注意点：当使用负数或者正负数开始和结束的索引时必须有交集才会有提取的元素
print(str1[-8:-1]) # %^&ASD
print(str1[-1:-8])
print(str1[5:-1]) # 是天秋老师!@#$ %^&ASD

# 对字符串进行切片操作时，可以设置步长:[开始:结束:步长]
print(str1[2:9:1]) # er我是天秋老
print(str1[2:9:2]) # e我天老

# 步长跳着取值：设置步长参数n-1跳取值的内容
print(str1[::-1]) # FDSA&^% $#@!师老秋天是我rewq
print(str1[-1:-8:-1]) # FDSA&^%
print(str1[-1:5: -1]) # FDSA&^% $#@!师老秋天

8.字符常用的操作方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
# str1 = "djsaia_ojiadsDaJAIODaJISAO2a8193a821a983是哦洒基@！#@！#@！ 都害怕21321aDSA"
# 1.查找字符串中具体某个元素的索引
# print(str1.find("哦")) # 41
# print(str1[41]) # 哦
# 从左往右查找元素直到找到为止返回索引值，如果有多个，返回最近的一个索引
# 设置索引范围查询("需要查找的元素",开始的索引，结束的索引)
# print(str1.find("a")) # 3
# print(str1.find("a", 6, 14)) # 10
# print(str1[6:14])
# 如果没有找到对应的元素索引，返回-1
# rfind从右边往左边找到第一个元素为"a"的索引
# print(str1.rfind("a")) # 62
# 2.查找字符串某个具体元素的索引
# str1 = "djsaia_ojiadsDaJAIODaJISAO2a8193a821a983是哦洒基@！#@！#@！ 都害怕21321aDSA"
# print(str1.index("a")) # 3
# print(str1.rindex("a")) # 62
# 设置索引范围查询("需要查找的元素",开始的索引，结束的索引)
# # 跟find方法的区别是没有找到元素时，index方法会报错，find返回-1
# print(str1.index("m")) # ValueError: substring not found
# 3.替换字符串中具体某个元素,默认替换所有，也可以设置替换几次
# print(str1.replace("a", "AB"))
# print(str1.replace("a", "AB", 3))
#
# print(str1.replace("d", " "))
# # 将字符串中所有的空格去除
# print(str1.replace(" ", ""))
# 4.字符切片方法
# str1 = "djsaia_ojiadsDaJAIODaJISAO2a8193a821a983是哦洒基@！#@！#@！ 都害怕21321aDSA"
# print(str1.split(
# "a")) # ['djs', 'i', '_oji', 'dsD', 'JAIOD', 'JISAO2', '8193', '821', '983是哦洒基@！
#@！#@！ 都害怕21321', 'DSA']
# 返回值是一个列表，通过a进行切片，将切片的内容当做列表的元素进行储存
# str2 = "a,b,c,d,1,2,3,4,5"
# print(str2.split(",")) # ['a', 'b', 'c', 'd', '1', '2', '3', '4', '5']
# 5.将字符串的英文首字母转大写
# 只要字母前面有任意符号包括数字就会进行转化为大写
# str3 = "jdiso@ajd2i o！saj#dio2san vvn2vno%w&qio e*nvn"
# str4 = "abc qwe zxc poi"
# print(str3.title())
# print(str4.title()) # Abc Qwe Zxc Poi
# 6.判断字符串是否已某个元素开头或者结尾
# str4 = "abc qwe zxc poi"
# print(str4.startswith("a")) # True
# print(str4.startswith("abc qwe")) # True
# print(str4.endswith("i")) # True
# print(str4.endswith("c poi")) # True
# print(str4.endswith("c pwoi")) # False
# 7.去除字符串左右两边的空格
# str4 = " abc qwe zxc poi "
# # 去除字符串包含所有空格可以使用是replace方法
# print(str4)
# # 去除左边
# print(str4.lstrip())
# print(str4.rstrip())
# 8.判断字符串是由数字组成
# str1 = "jdisaojdisoajdsa"
# str2 = "jdisaojdisoajdsadDSAD"
# str3 = "jdisaojdisoajdsadDSAD21321312"
# str4 = "3213213122132131"
# print(str1.isdigit()) # False
# print(str2.isdigit()) # False
# print(str3.isdigit()) # False
# print(str4.isdigit()) # True
# 9.判断字符串中是不是由字母组成，大小都可以
# str1 = "jdisaojdisoajdsa"
# str2 = "jdisaojdisoajdsadDSAD"
# str3 = "jdisaojdisoajdsadDSAD21321312"
# str4 = "3213213122132131"
# str5 = "SDADSADSADSA"
# print(str1.isalpha()) # True
# print(str2.isalpha()) # True
# print(str3.isalpha()) # False
# print(str4.isalpha()) # False
# print(str5.isalpha()) # True
# 10.将某个字符，拼接整个字符串
# str1 = "renshengkuduanwoyongpython"
# print("-".join(str1))
# print(" ".join(str1))
# print("*".join(str1))

总结： 字符串常用的方法不仅限于以上内容，不需要记住每个方法的名字，学习方法的具体使用即可

9.列表的常用操作方法

列表属于容器类型的数据，也是有序的，可以通过索引取元素值，及切片

列表常用的方法：增，删，改，查

9.1查询数据

通过元素的索引提取元素值

1
2
3
4
5
6
7
8
9
10
list1 = [1, 2, 3, 4, False, True, [3, 4, 5], (7, 8), 3.13, "jd_si_ao"]
# print(len(list1)) # 10
# print(list1)
# 通过索引获取元素值
print(list1[4]) # False
print(list1[-1]) # jd_si_ao
print(list1[:]) # 获取列表所有的值
print(list1[::-1]) # 获取列表所有的值进行反转
print(list1[1:5]) # [2, 3, 4, False]
print(list1[-5:-1]) # [True, [3, 4, 5], (7, 8), 3.13]

3.2修改数据

通过元素索引提取元素值之后重复赋值

1
2
3
4
5
list1 = [1, 2, 3, 4, False, True, [3, 4, 5], (7, 8), 3.13, "jd_si_ao"]
print(list1[5])
list1[5] = 1
# 对原生的列表执行操作之后，原生列表会发生对应的变化
print(list1)

3.3删除数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 删除数据
# list1 = [1, 2, 3, 4, False, True, [3, 4, 5], (7, 8), 3.13, "jd_si_ao"]
# print(list1)
# # 第一种方式：使用pop方法通过索引删除元素
# list1.pop() # 默认删除列表最后一个元素
# print(list1)
# # 指定索引删除
# # list1.pop(6)
# list1.pop(-3)
# print(list1)
# 第二种方式：使用remove指定删除具体元素
# list1.remove(False)
# list1.remove((7, 8))
# print(list1)
# 第三种方式，使用关键字进行删除
# 需要先提取元素再使用关键字
# del list1[-2]
# print(list1)
list1 = [1, 2, 3, 4, False, True, [3, 4, 5], (7, 8), 3.13, "jd_si_ao"]
# 第四种方式:清空列表
list1.clear()
print(list1)

3.4增加数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 增加数据
# 第一种方式：使用append方法添加单个数据
# list1.append("888") # 默认加到列表的末尾
# print(list1)
# list1.append([1, 76, 5, 4])
# print(list1)
# 第二种将多个元素拆分添加
# list1.extend([1, 76, 5, 4])
# print(list1)
# list1.extend("djsaiodjsioa")
list1.extend("888")
list1.extend("a")
print(list1)
list1 = [1, 2, 3, 4, False, True, [3, 4, 5], (7, 8), 3.13, "jd_si_ao"]
list1 = [1, 2, 3, 4, False, True, [3, 4, 5], (7, 8), 3.13, "jd_si_ao"]
# 第三种指定索引添加数据：insert
# list1.insert(-1, "666")
# list1.insert(1, "666")
# list1.insert(4, "666")
# list1.insert(9, "666")
# 如果插入的索引值超过最大索引，那么默认插入到最后
# list1.insert(10, "666")
list1.insert(100, "666")
print(list1)

列表嵌套通过索引取元素值：

1
2
3
4
5
6
# list1 = [1, 2, 3, 4, False, True, [3, 4, 5], (7, 8), 3.13, "jd_si_ao"]
# # 如果列表中嵌套列表或者元组需要通过索引取值
# # print(list1[6])
# print(list1[6][2]) # 5
# print(list1[7][1]) # 8

4.元组常用操作方法

元组和列表一样，是有序的容器类型，那么也支持索引获取元素值，以及切片

元组一旦被定义就是唯一的，数据不能被修改，否则跟原生数据没有任何关系

元组只支持查询操作，不能删除，增加，修改

1
2
3
4
5
6
7
8
9
10
t1 = 1, 2, 3, 4, 5, 2, 2, 78, 9, 4, 2, "a", "v", 2, 2, 1, 2
# print(t1[-2])
# print(t1[:6])
# print(t1[6:])
# print(t1[::-1])
# 统计元素出现的次数，列表也支持这个方法
print(t1.count(2)) # 7次
# 通过元素获取索引
print(t1.index(78)) # 7
print(t1[7]) # 78

5.字典常用操作方法

5.1查询数据

1
2
3
4
5
6
7
8
9
10
11
12
dict1 = {"name": "刘亦菲", "age": 18, "sex": "女"}
# {键:值}
# 通过字典的键获取值
# print(dict1["name"]) # 刘亦菲
# print(dict1["age"]) # 18
# print(dict1["sex"]) # 女
# 获取字典中所有的键
print(dict1.keys()) # ['name', 'age', 'sex']
# 获取字典中所有的值
print(dict1.values()) # ['刘亦菲', 18, '女']
# 获取字典中所有的键值对
print(dict1.items()) # [('name', '刘亦菲'), ('age', 18), ('sex', '女')]

5.2增加数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 简写方式创建字典
dict2 = dict(a=1, b=2, c=3)
print(dict2)
# 给字典添加键值对
# dict2.update({"d": 4})
# print(dict2) # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# 注意：如果添加字典中键存在，那么会覆盖原来的值
# dict2.update({"a": 6, "e": 9})
# print(dict2)
# 如果添加的键值对，键存在，不覆盖原来的值
dict2.setdefault("a", 666) # {'a': 1, 'b': 2, 'c': 3}
print(dict2)
# 如果字典中没有见，那么新增键值对
dict2.setdefault("d", 666) # {'a': 1, 'b': 2, 'c': 3, 'd': 666}
print(dict2)

5.3修改数据

通过字典的键修改字典的值进行重复赋值

1
2
3
4
dict2 = dict(a=1, b=2, c=3)
print(dict2)
dict2["a"] = 666
print(dict2) # {'a': 666, 'b': 2, 'c': 3}

5.4删除数据

1
2
3
4
5
6
7
8
dict2 = dict(a=1, b=2, c=3)
print(dict2)
# 使用pop方法删除指定的键，对应的键值对
# dict2.pop("b")
# print(dict2) # {'a': 1, 'c': 3}
# 使用clear方法清楚所有键值对
dict2.clear()
print(dict2) # {}

6.集合常用操作方法

集合的特性是没有重复的数据，自动去重

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
set1 = {1, 2, 3, 2, 1, 2, 3, 1, 2, 3, 4, 5, 6, 7}
print(set1) # 默认去重
# 集合中可以添加数据，但是重复的数据无效
# set1.add(8)
# print(set1)
# set1.add(1)
# set1.add(2)
# print(set1)
# 删除数据
# set1.remove(7)
# set1.remove(1)
# print(set1)
# 集合由于不重复的特性，所以属于无序的序列
# 集合不支持切片和索引提取元素
# print(set1[4])