Python的数据类型

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)