Python的数据类型

数据类型

1.数据类型

（一）数字类型：int float bool不可变

bool 布尔

True：非0数字、非空字符串、非空的列表、集合、元组、字典

False：0、0.0、none、空字符串、’’、””、[]、{}、()

n = int(input("请输入一个整数："))

m = int(input("请再输入一个整数："))

if n > m:

print("第一个值大！")

elif n == m:

print("两个值相等！")

else:

print("第二个值大！")

#让用户输入一段内容，然后把用户输入的内容打印出来；如果用户啥也不输入（直接回车），就打印 None

def get_res(res=None):

res = input("请输入内容：")

if res:

return res

# res=None的作用：当函数没有写return结果时，默认返回None（因此这句写不写都行），这是Python默认规则

print(get_res())

# str字符串

s1 = 'hello'

s2 = 'world'

# print(s1 + ''+s2)

# f-string格式化方式

print(f"{s1}-{s2}")

# %d 整数 %f 浮点数 %s 字符串

print("%s---%s" % (s1,s2))#用---隔开，输出hello---world

# 重复

print(s1 * 10) #重复输出十遍

# 获取长度len

print(len(s1)) #输出5

# 切片 hello

print(s1[0]) #输出h

print(s1[0:2]) #输出he

print(s1[0::2]) #输出hlo

（二）字符串：str 文本处理、格式化、查找、替换等操作不可变

#!/usr/bin/python3

str = 'Runoob'# 定义一个字符串变量

print(str)# 打印整个字符串

print(str[0:-1])# 打印字符串第一个到倒数第二个字符（不包含倒数第一个字符）

print(str[0])# 打印字符串的第一个字符

print(str[2:5])# 打印字符串第三到第五个字符（不包含索引为 5 的字符）

print(str[2:])# 打印字符串从第三个字符开始到末尾

print(str * 2)# 打印字符串两次

print(str + "TEST")# 打印字符串和"TEST"拼接在一起

输出结果：

Runoob

Runoo

R

noo

noob

RunoobRunoob

RunoobTEST

通过Python 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，能够在字符串前面添加一个 r，表示原始字符串

（三）列表：list 有序、可变，存储一组有序且可变的数据，使用下标修改、查找、删除等操作

#!/usr/bin/python3

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ] # 定义一个列表

tinylist = [123, 'runoob']

print (list)# 打印整个列表

print (list[0])# 打印列表的第一个元素

print (list[1:3])# 打印列表第二到第四个元素（不具备第四个元素）

print (list[2:])# 打印列表从第三个元素开始到末尾

print (tinylist * 2)# 打印tinylist列表两次

print (list + tinylist)# 打印两个列表拼接在一起的结果

输出结果：

['abcd', 786, 2.23, 'runoob', 70.2]

abcd

[786, 2.23]

[2.23, 'runoob', 70.2]

[123, 'runoob', 123, 'runoob']

['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

（四）元组：tuple 有序、不可变，用于函数传参以及返回值的使用

元组：不可变的列表，元组一旦创建元素不可变，使用圆括号 () 定义。

tup = (1, 2, 3, 4, 1, 1, 1, 1)

print(sum(tup))

print(tup[0])

print(tup.count(1))

print(tup.index(3))

s = ()

# ('a',) -> <class 'tuple'>

# a -> <class 'str'>

# () -> <class 'tuple'>

print(s, '->', type(s))

（五）字典：dict 键值对存储，K-V结构，通过key来获取value

dic = {

'name': 'tom',

'age': 18

}

# 当key不存在时，添加新元素（key-value）；当键存在时，修改值

dic['addr'] = '北京'# 键不存在就是添加新元素-键值对

dic.update({'email': 'xxx'})# 第二种办法添加

dic['name'] = 'Bob'# 键存在就是修改值

# 查找数据dict[key] / dict.get(key,default)

print(dic['name'])

print((dic.get('xxx')))# get在不存在时也不会报错

# 删除

dic.pop('age') # pop删除后会返回对应的值（键不存在则返回default）

del dic['age']# 只删除，不返回值（键不存在会报错）

# 清空字典

dict.clear()

print(dic)

# 获取字典中所有的键

print(dic.keys())

# 获取字典中所有的值

print(dic.values())

# 转换字典->序列

print(dic.items())

# 类型转换成列表，可以通过下标取值

print(list(dic.items())[0])

#把键值对写成特定的格式

for k, v in dic.items():

print(k, '->', v)

序号就是# 三个变量，i

for i, (k, v) in enumerate(dic.items()):

print(i, k, v)

# 判断类型，会输出True或者False

print(isinstance([1, 2, 3], int))

（六）集合：set 相当于只有key的字典，元素不能重复，用来去重以及集合运算

s1 = {1, 2, 3, 4}

s2 = {3, 4, 5, 6}

print(s1 & s2)# 交集：两个集合中相同的内容，输出{3, 4}

print(s1 | s2)# 并集:两个集合合并后的内容，输出{1, 2, 3, 4, 5, 6}

print(s1 - s2)# 差集:去除两个集合相同的内容，谁在前就谁来减，输出{1, 2}

print(s2 - s1)# 输出{5, 6}

print(s1 ^ s2)# 异或差集：先删除交集的内容，然后合并，输出{1, 2, 5, 6}

s1.update({7})# 添加一个元素，输出{1, 2, 3, 4, 7}

s1.add(8)# 添加一个元素，输出{1, 2, 3, 4, 7, 8}

s1.pop()# 随机删除一个元素，输出{2, 3, 4, 7, 8}

s1.remove(4)# 直接删除某个元素，输出{2, 3, 7, 8}

s1.clear()# 清空

print(s1)

2.结构化编程

3.函数式编程

4.面向对象编程

5.模块化编程

# Python基础：变量、循环判断、数据类型、函数、面向对象、模块开发

# Python运维自动化：网络模块、数据库模块、系统管理模块

# Python Web开发：flask、Django、fastapi

# Python 爬虫

数据类型转换

# 类型转换

num = "123"

print(num+"1")#字符串拼接，输出1231

print(int(num)+1)#数字相加，输出124

# str -> int

num = "1010"

print(int(num, base=2))#字符串转为二进制，输出10

num = "ABCDEF"

print(int(num, base=16))#字符串转为十六进制，输出11259375

# str -> float

num = "3.14"

print(float(num))#字符串转为浮点数，输出3.14

# int -> float

print(float(3))#整数转为浮点数，输出3.0

# float -> int

print(int(3.9999))#浮点数转为整数，输出3

# int -> str

print(str(1111))#整数转为字符串，输出1111

print(type(str(1111)))#查看数据类型，发现是str

# str -> list

print(list("Python"))#输出['P', 'y', 't', 'h', 'o', 'n']

# list -> str

print(str(['a','b','c']))#列表转字符串，输出['a', 'b', 'c']

print("".join(['a','b','c']))#引号里加什么就用什么分隔，如果里面有不是字符串的会报错

# list -> tuple

print(tuple([1,2,3,4]))#列表转元组，输出(1, 2, 3, 4)

# list -> set

print(set([1,1,1,1,2,2,2,3,3]))#列表转为集合，输出{1, 2, 3}

# !/usr/bin/python3

str = 'Runoob'# 定义一个字符串变量，不建议用str关键字

print(str)# 打印整个字符串

print(str[0:-1])# 打印字符串第一个到倒数第二个字符（不包后包前）

print(str[0])# 打印字符串的第一个字符

print(str[2:5])# 打印字符串第三到第五个字符（不包含索引为 5 的字符）

print(str[2:])# 打印字符串从第三个字符开始到末尾

print(str * 2)# 打印字符串两次

print(str + "TEST")# 打印字符串和"TEST"拼接在一起

# 比大小的例子

n = int(input("请输入一个整数："))

m = int(input("请再输入一个整数："))

if n > m:

print("第一个值大！")

elif n == m:

print("两个值相等！")

else:

print("第二个值大！")

# 让用户输入一段内容，然后把用户输入的内容打印出来；假设用户啥也不输入（直接回车），就打印 None

def get_res(res=None):# res=None的作用：当函数没有写return结果时，默认返回None（所以这句写不写都行），这是Python默认规则

res = input("请输入内容：")

if res:

return res

print(get_res())

# # str字符串

s1 = 'hello'

s2 = 'world'

# print(s1 + ''+s2)

# f-string格式化方式

print(f"{s1}-{s2}")

# %d 整数 %f 浮点数 %s 字符串

print("%s---%s" % (s1, s2))# 用---隔开，输出hello---world

# 重复

print(s1 * 10)# 重复输出十遍

# 获取长度len

print(len(s1)) # 输出5

# 切片 hello

print(s1[0]) # 输出h

print(s1[0:2])# 输出he

print(s1[0::2])# 输出hlo

print(s1[::-1])# 第三个参数为负数表示逆向读取，翻转字符串，输出olleh

print(s1[2:5])# 输出llo

Python流程控制语句（包括条件判断语句和循环语句）

模块 1：条件判断（if-elif-else）

作用：根据条件选择执行不同代码，依赖「冒号 + 缩进」区分代码块。

  1. 单分支（if）

语法：if 条件: 代码块

案例：判断是否成年

age = 19

if age >= 18:

print("已成年")# 输出：已成年

  1. 双分支（if-else）

语法：if 条件: 代码块1 else: 代码块2（二选一执行）

案例：判断考试是否及格

score = 58

if score >= 60:

print("及格")

else:

print("不及格")# 输出：不及格

  1. 多分支（if-elif-else）

语法：if 条件1: 代码块1 elif 条件2: 代码块2 else: 代码块3（按顺序判断，只执行第一个满足的分支）

案例：成绩评级

score = 85

if score >= 90:

print("优秀")

elif score >= 80: # 仅score<90时判断

print("良好") # 输出：良好

elif score >= 60:

print("及格")

else:

print("不及格")

  1. 嵌套条件

语法：条件语句内部嵌套另一个条件语句

案例：判断是否可进入场所

age = 20

has_id = True

if age >= 18:

if has_id:

print("可进入")# 输出：可进入

else:

print("需出示身份证")

else:

print("未满18岁，不可进入")

模块 2：循环语句

作用：重复执行代码块，分for（遍历序列）和while（条件循环）两类。

  1. for 循环（遍历序列）

语法：for 变量 in 序列: 代码块

案例 1：遍历字符串 / 列表

# 遍历字符串

for char in "Python":

print(char)# 逐行输出：P、y、t、h、o、n

# 遍历列表

fruits = ["苹果", "香蕉", "橙子"]

for fruit in fruits:

print(f"我喜欢吃{fruit}")# 输出：我喜欢吃苹果...

案例 2：用range()生成数字序列

# range(开始, 结束, 步长)，左闭右开

for i in range(2, 8, 2):# 从2到7，步长2

print(i)# 输出：2、4、6

  1. while 循环（条件循环）

语法：while 条件: 代码块（需更新条件防无限循环）

案例 1：计数循环

count = 0

while count < 3:

print(f"计数：{count}")# 输出：计数0、1、2

count += 1# 必须更新条件

案例 2：无限循环（用 break 退出）

while True:

user_input = input("输入'q'退出：")

if user_input == 'q':

break # 输入q则退出

print(f"你输入了：{user_input}")

  1. 循环控制语句

关键字

作用

案例（输出 0、1、3、4）

break

跳出整个循环

if i==3: break

continue

跳过本次循环剩余代码

if i==2: continue

pass

占位（暂不写代码）

if i==1: pass

  1. 循环的 else 子句（Python 特色）

作用：循环未被 break 中断时，执行 else 代码块

案例：查找列表元素

fruits = ["苹果", "香蕉", "橙子"]

for fruit in fruits:

if fruit == "葡萄":

print("找到葡萄")

break

else:

print("未找到葡萄")# 输出：未找到葡萄

模块 3：基础语法 & 实用工具

1.三目运算（简化条件判断）

语法：变量 = 值1 if 条件 else 值2

案例：判断奇偶

print('偶数' if int(input('输入整数:'))%2==0 else '奇数')

2.数据的 “真假” 判断

真（True）

假（False）

非 0 数字（1、-2、3.14）

0、0.0

非空容器（"abc"、[1,2]）

空容器（""、[]、{}）

True

False、None

3.实用案例：判断闰年

year = int(input("输入年份："))

if (year%4==0 and year%100!=0) or year%400==0:

print(f"{year}是闰年")

else:

print(f"{year}不是闰年")

4.Python 之禅（编程规范）

核心原则：优雅 > 丑陋、简洁 > 复杂、易读最重要（执行import this查看全文）

模块

核心内容（口诀 + 要点）

条件判断

用if-elif-else，冒号 + 缩进
单分支：if 条件→执行
多分支：elif 按顺序判断，只走一个
嵌套：if 里套 if

循环

for：遍历序列（for 变量 in 序列），range(a,b,步长)生数字
while：条件成立就循环，需更新条件防死循环
循环 else：没被 break 中断才执行

循环控制

break：跳整个循环
continue：跳本次循环
pass：占位不执行

基础语法

三目运算：变量=值1 if 条件 else 值2
数据真假：非 0 / 非空→真，0 / 空 / False→假
字符串格式化：f"{变量}"

举个栗子

for循环格式：

for 变量 in 序列:

循环体

遍历序列中的元素；遍历：按照顺序依次获取一个值

pass：空语句，仅作为语法占位符

当语法上需要语句但暂时不执行任何操作时使用（如未做完的代码框架），避免语法错误。

for i in range(3):

if i == 1:

pass # 暂不处理，后续补充

else:

print(i) # 输出：0、2

print(list(range(10)))#遍历0-10的数

# 输出一个个的字符串

for i in "Python":

print(i)

for i in ["a", "b", "c"]:

print(i)

dic = {1: 'A', 2: 'B', 3: 'C'}

for i in dic:

print(dic[i])

求最值

# 循环接收用户输入的数字，存储到列表中，最后计算并输出这些数字的「最大值、最小值、总和、平均值」，输入 q 或 Q 可以退出输入

lis = []

while True:

ch = input("请输入数字,输入q退出:")

if ch in ('q', 'Q'):

break

lis.append(float(ch))

print(lis)

print("最大值:", max(lis))

print("最小值:", min(lis))

print("求和:", sum(lis))

print("平均值:", round(sum(lis) / len(lis)), 2)#四舍五入，两位小数

# 最多接收用户输入 5 个数字（支撑小数），或输入 q/Q 提前退出，最后计算并输出已输入数字的「最大值、最小值、总和、平均值」

num = 0

lis = []

while num < 5:

ch = input("请输入数字,输入q退出:")

if ch in ('q', 'Q'):

break

lis.append(float(ch))

num += 1

else:

print("输入结束！")

print(lis)

print("最大值:", max(lis))

print("最小值:", min(lis))

print("求和:", sum(lis))

print("平均值:", round(sum(lis) / len(lis), 2))

五个小案例

1.百钱百鸡:公鸡5元，母鸡3元，小鸡1元三只，100元买100只鸡，各有多少只鸡：

def hundred_chickens():

print("百钱百鸡")

for cock in range(0, 21):

for hen in range(0, 34):

chick = 100 - cock - hen

if chick % 3 == 0 and 5 * cock + 3 * hen + chick // 3 == 100:

print(f"公鸡：{cock}只，母鸡：{hen}只，小鸡：{chick}只")

hundred_chickens()

print()

2.鸡兔同笼问题，90脚，40个头，有多少只兔子，多少只鸡：

for j in range(41):

t = 40 - j

if 2 * j + 4 * t == 90:

print(f'鸡:{j},兔:{t}')

3.水仙花数，一个三位数 100~999,个位三次方+十位三次方+百位三次方法=它本身：

for number in range(100, 1000):

b = int(str(number)[0])# 百位,153//100 = 1

s = int(str(number)[1])# 十位,(153%100) //10 = 5

g = int(str(number)[2])# 个位,153%10 = 3

if b ** 3 + s ** 3 + g ** 3 == number:

print(number)

4.9*9乘法表：

for i in range(1, 10):# 外层循环控制行数（1到9）

for j in range(1, i + 1):# 内层循环控制每行的列数（第i行有i列）

print(f"{i}x{j}={i*j}", end=" ")# 让print不换行，用空格分隔

print()# 每行结束后换行

5.斐波那契数列，兔子序列;

fei_bo = [1, 1]

while True:

n = fei_bo[-1] + fei_bo[-2]

if n > 10000:

break

fei_bo.append(n)

print(fei_bo)

字符串常用方法

# 字符串常用方式

string = "Python"

# 将列表中的字符合并为一个字符串

print("".join(['H', 'e', 'l', 'l', 'o']))

# 去除字符开头与结尾的空格或其他符号

print("#####shangsan######".strip('#'))

print(" lisi ".lstrip())# 只去除左侧的空格

print(" wangwu ".rstrip())# 只去除右侧的空格

空格就是# 切割：借助分隔符拆分列表,默认分隔符

lis = "root:0:0::/root:/bin/bash".split(":")

lis[0] = "admin"

print(":".join(lis))

# 居中展示

print(string.center(20))

# find查找:凭借字符查找下标

print(string.index('n'))

# replace:字符替换

print(string.replace("P", "J"))

print(string)

##验证字符由纯数字构成

print("123".isdigit())

ch = input("请输入一个数字:")

if ch.isdigit():

print("您的输入正确！")

else:

print("您的输入有误！")

# 验证是否是纯字母构成

print("abc".isalpha())

# 验证是否是数字+字母构成

print("1a2b".isalnum())

# 验证纯小写、纯大写、大小写转换

print("abc".islower())

print("ABC".isupper())

print("ABCdef".swapcase())

# count:统计字符出现的数量

print("hello".count('l'))

# title：把首字母变成大写

print("abc".title())

#

# ord 字符 -> 数字编号

c = input("请输入一个小写字母：")

print(chr(ord(c) - 32))

# chr 数字-> 字符

# int\float\bool\list\dict\max\sum\min\len\round\input\print

#

"Python"

# 判断以"xxx"开头，以"xxx"结尾

print(string.endswith('n'))

print(string.startswith('P'))

list常用方法

1.可变

2.有序

3.能够嵌套

4.异构：同一个列表中可以存放任意类型的内容；

list的方法

1.创建列表

lis1 = []

lis2 = list()

2.添加数据

# 1.append(元素)，在结尾追加的作用

lis1.append('a')

lis1.append([1,2,3])

print(lis1)

# 2.合并序列

lis1.extend([1,2,3])

lis3 = lis1 + lis2

# 等价于+=，输出1,2,3,[1,2,3]

# 3.在列表任意位置添加元素，insert(下标,元素)

lis1.insert(0,’X’) # 在下标0的位置添加一个元素，尽量不在开头添加

3.查找数据

print(lis1.index(‘a’))

print(lis1.count(2))# 查找数字不能带引号，带引号是字符串

4.修改内容：凭借下标直接修改列表中的值

lis1[1] =‘b’

print(lis1)

5.删除信息

# 1.pop()：通过下标弹出元素；

a = lis1.pop(2)# 不写下标默认弹出最后一个

print(lis1)

print(a)

# 2.del关键字：从内存中删除

# del lis1 # 不写下标的话会删除所有，输出结果会报错

del lis1[0]

print(lis1)