Python 入门基础

第一个Python程序之打印 Hello World!

print("Hello World!")

字符串定义的三种方式，type 用了检测数据类型

# 单引号定义法，使用单引号进行包围
name = '测试'
print(type(name))
# 双引号定义法
name = "测试"
print(type(name))
# 三引号定义法，写法和多行注释是一样的
name = """
我是
小白
"""
print(type(name))

# 在字符串内 包含双引号
name = '"包含双引号"'
print(name)
# 在字符串内 包含单引号
name = "'包含单引号'"
print(name)
# 使用转义字符 \ 解除引号的效用
name = "\"解除引号的效用\""
print(name)
name = '\'解除引号的效用\''
print(name)

Python 中的各类运算符

# 算术（数学）运算符
print(1 + 1) #加
print(2 - 1) #减
print(3 * 3) #乘
print(4 / 2) #除
print(11 // 2) #取整除
print(9 % 2) #取余
print(2 ** 2) #指数

# 赋值运算符
num = 1 + 2 * 3

# 复合赋值运算符
num = 1
num += 1 #加法赋值运算符 等效于 num = num + 1
num -= 1 #减法赋值运算符
num *= 4 #乘法赋值运算符
num /= 2 #除法赋值运算符
num %= 2 #取模赋值运算符
num **=2 #幂赋值运算符
num //= 2 #取整除赋值运算符

Python 中的 input 语句，获取键盘的输入信息

name = input("请告诉我你是谁？")
print("我知道了，你是:%s" % name)

字符串格式化的方式

#1、第一个 %s 占位，第二个% 后面跟变量。%s 将内容转换成字符串，放入占位位置。
print("1 * 1 的结果是：%s" % (1 * 1))# 定义变量 %d 将内容转换成整数，放入占位位置。%f 将内容转换成浮点型，放入占位位置
stock_price_daily_growth_factor = 1.2
growth_days = 7.1
finally_stock_price = 71.63
print("每日增长系数: %.1f，经过%d天的增长后，股价达到了：%.2f" % (stock_price_daily_growth_factor, growth_days, finally_stock_price))
# 打印结果：每日增长系数: 1.2，经过7天的增长后，股价达到了：71.63#2、f"{占位}"
print(f"1 * 2的结果是：{1 * 2}")

布尔类型和比较运算符

# 01_布尔类型和比较运算符
bool_1 = True
bool_2 = False
print(f"bool_1变量的内容是：{bool_1}, 类型是：{type(bool_1)}")
print(f"bool_2变量的内容是：{bool_2}, 类型是：{type(bool_2)}")
# 比较运算符的使用
# == , !=, >, <, >=, <=
# 演示进行内容的相等比较
num1 = 10
num2 = 10
print(f"10 == 10的结果是：{num1 == num2}")num1 = 10
num2 = 15
print(f"10 != 15的结果是：{num1 != num2}")name1 = "itcast"
name2 = "itheima"
print(f"itcast == itheima 结果是：{name1 == name2}")# 演示大于小于，大于等于小于等于的比较运算
num1 = 10
num2 = 5
print(f"10 > 5结果是：{num1 > num2}")
print(f"10 < 5的结果是：{num1 < num2}")num1 = 10
num2 = 11
print(f"10 >= 11的结果是：{num1 >= num2}")
print(f"10 <= 11的结果是：{num1 <= num2}")

if语句的基本格式应用

age = 10if age >= 18:print("我已经成年了")print("时间过的真快呀")

if else的组合判断语句

age = int(input("请输入你的年龄："))if age >= 18:print("您已成年，需要买票10元。")
else:print("您未成年，可以免费游玩。")

if elif else 多条件判断语句的使用

# 多条件判断的语法
if int(input("请输入你的身高（cm）：")) < 120:print("身高小于120cm，可以免费。")
elif int(input("请输入你的VIP等级（1-5）：")) > 3:print("vip级别大于3，可以免费。")
elif int(input("请告诉我今天几号：")) == 1:print("今天是1号免费日，可以免费")
else:print("不好意思，条件都不满足，需要买票10元。")

while语句的基本格式应用

i = 0
while i < 100:print("小美，我喜欢你")i += 1

while循环的嵌套使用

# 外层：表白100天的控制
# 内层：每天的表白都送10只玫瑰花的控制
i = 1
while i <= 100:print(f"今天是第{i}天，准备表白.....")# 内层循环的控制变量j = 1while j <= 10:print(f"送给小美第{j}只玫瑰花")j += 1print("小美，我喜欢你")i += 1print(f"坚持到第{i - 1}天，表白成功")

while的嵌套循环打印输出九九乘法表

# 定义外层循环的控制变量
i = 1
while i <= 9:# 定义内层循环的控制变量j = 1while j <= i:# 内层循环的print语句，不要换行，通过\t制表符进行对齐print(f"{j} * {i} = {j * i}\t", end='')j += 1i += 1print()     # print空内容，就是输出一个换行

for循环的基础语法

name = "itheima"for x in name:# 将name的内容，挨个取出赋予x临时变量# 就可以在循环体内对x进行处理print(x)

break 结束本循环

#计算1-10之和，但是如果和超过20以后，就不再循环了，直接打印和是多少，i循环到几了
i=1
s=0
while i<10:s+=iif s>20:breaki+=1
print ('s=',s,'i=',i)   #结果是s=21，i=6

continue 结束本次循环，继续执行下一次循环

#计算1-100的偶数和
s=0
for i in range(1,101):if i%2==1:   #当i跟2取余是1时，表示这是个奇数，则不执行本次循环continues+=i
print (s)   #2550

return 结束整个程序运行

# 1-100内的偶数和
def fun():s = 0for i in range(1, 101):if i % 2 == 1:return s  # 碰到奇数就返回s的值s += iprint(s)print(fun())  # 调用函数，并打印结果

Python中的range()语句的基本使用

# range是python中的一个内置函数，用于生成一系列连续的整数，创建一个整数列表，一般用在 for 循环中
# range()函数语法
range(start, stop[, step])

# range语法1 range(num)
# for x in range(10):
#     print(x)# range 语法2 range(num1, num2)
# for x in range(5, 10):
#     # 从5开始，到10结束（不包含10本身）的一个数字序列，数字之间间隔是1
#     print(x)# range 语法3 range(num1, num2, step)
# for x in range(5, 10, 2):
#     # 从5开始，到10结束（不包含10本身）的一个数字序列，数字之间的间隔是2
#     print(x)for x in range(10):# 默认从0开始，不包含10print(f"{x}")# 错误写法，不能直接写5
for x in 5:# 默认从0开始，不包含10print(f"{x}")

Python for循环临时变量的作用域

i = 0
for i in range(5):print(i)print(i)

for循环打印九九乘法表

# 通过外层循环控制行数
for i in range(1, 10):# 通过内层循环控制每一行的数据for j in range(1, i + 1):# 在内层循环中输出每一行的内容print(f"{j} * {i} = {j * i}\t", end='')# 外层循环可以通过print输出一个回车符print()

嵌套应用for循环

# 坚持表白100天，每天都送10朵花
# range
i = 0
for i in range(1, 101):print(f"今天是向小美表白的第{i}天，加油坚持。")# 写内层的循环了for j in range(1, 11):print(f"给小美送的第{j}朵玫瑰花")print("小美我喜欢你")print(f"第{i}天，表白成功")

函数的定义语法

# 定义一个函数，输出相关信息
def say_hi():print("Hi 我是程序员，学Python")# 调用函数，让定义的函数开始工作
say_hi()

函数使用参数

# 定义2数相加的函数，通过参数接收被计算的2个数字
def add(x, y, z):result = x + y + zprint(f"{x} + {y} + {z}的计算结果是：{result}")# 调用函数，传入被计算的2个数字
add(5, 6, 7)

定义函数返回值的语法格式

# 定义一个函数，完成2数相加功能
def add(a, b):result = a + b# 通过返回值，将相加的结果返回给调用者，return 后函数执行结束return result# 函数的返回值，可以通过变量去接收
r = add(5, 6)
print(r)

def add(x, y):#add函数可以接收2个参数，进行2数相加的功能#:param x: 形参x表示相加的其中一个数字#:param y: 形参y表示相加的另一个数字#:return: 返回值是2数相加的结果result = x + yprint(f"2数相加的结果是：{result}")return resultadd(5, 6)

嵌套调用函数

# 定义函数func_b
def func_b():print("1")
# 定义函数func_a，并在内部调用func_b
def func_a():print("2")# 嵌套调用func_bfunc_b()print("3")
# 调用函数func_a
func_a()# 调用结果：2 1 3

函数使用的时候，定义的变量作用域

# 变量在函数体内成为了函数的局部变量
def test_a():num = 100print(num)test_a()
#出了函数体，局部变量就无法使用了
print(num)

函数的多返回值示例

# 演示使用多个变量，接收多个返回值
def test_return():return 1, "hello", True
# 定义多个变量
x, y, z = test_return()
# 依次调用
print(x)
print(y)
print(z)

# 多种传参的形式
def user_info(name, age, gender):print(f"姓名是:{name}, 年龄是:{age}, 性别是:{gender}")
# 位置参数 - 默认使用形式
user_info('小明', 20, '男')# 关键字参数
user_info(name='小王', age=11, gender='女')
user_info(age=10, gender='女', name='潇潇')    # 可以不按照参数的定义顺序传参
user_info('甜甜', gender='女', age=9)# 缺省参数（默认值）
def user_info(name, age, gender):print(f"姓名是:{name}, 年龄是:{age}, 性别是:{gender}")user_info('小天', 13, '男')# 不定长 - 位置不定长, *号,打印结果为元祖
# 不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入
def user_info(*args):print(f"args参数的类型是：{type(args)}，内容是:{args}")user_info(1, 2, 3, '小明', '男孩')# 不定长 - 关键字不定长, **号，打印结果为List
def user_info(**kwargs):print(f"args参数的类型是：{type(kwargs)}，内容是:{kwargs}")
user_info(name='小王', age=11, gender='男孩')

lambda匿名函数

# 定义一个函数，接受其它函数输入
def test_func(compute):result = compute(1, 2)print(f"结果是:{result}")
# 通过lambda匿名函数的形式，将匿名函数作为参数传入
def add(x, y):return x + y# 函数作为参数传递
test_func(add)# 使用 lambda 可以不定义 add 方法。x，y 代表形参，x+y 是运算
test_func(lambda x, y: x + y)

数据容器之list列表。语法：[元素，元素，…]

# 定义一个列表 list
my_list = ["itheima", "itcast", "python"]
print(my_list)
print(type(my_list))my_list = ["itheima", 666, True]
print(my_list)
print(type(my_list))# 定义一个嵌套的列表
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))# 通过下标索引取出对应位置的数据
my_list = ["Tom", "Lily", "Rose"]
# 列表[下标索引], 从前向后从0开始，每次+1，  从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范；通过下标索引取数据，一定不要超出范围
# print(my_list[3])# 通过下标索引取出数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])# 取出嵌套列表的元素
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list[1][1])

list 列表方法预览

list列表的常用方法演示

mylist = ["itcast", "itheima", "python"]# 1.1 查找某元素在列表内的下标索引 index方法
index = mylist.index("itheima")
print(f"itheima在列表中的下标索引值是：{index}")
# 结果：itheima在列表中的下标索引值是：1# 1.2如果被查找的元素不存在，会报错
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引值是：{index}")# 2. 修改特定下标索引的值
mylist[0] = "python"
print(f"列表被修改元素值后，结果是：{mylist}")
# 结果：列表被修改元素值后，结果是：['python', 'itheima', 'python']# 3. 在指定下标位置插入新元素 insert 方法
mylist.insert(1, "best")
print(f"列表插入元素后，结果是：{mylist}")
# 结果：列表插入元素后，结果是：['python', 'best', 'itheima', 'python']# 4. 在列表的尾部追加```单个```新元素 append 方法
mylist.append("程序员")
print(f"列表在追加了元素后，结果是：{mylist}")
# 结果：列表在追加了元素后，结果是：['python', 'best', 'itheima', 'python', '程序员']# 5. 在列表的尾部追加```一批```新元素 extend 方法
mylist2 = [1, 2, 3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是：{mylist}")
# 结果：列表在追加了一个新的列表后，结果是：['python', 'best', 'itheima', 'python', '程序员', 1, 2, 3]# 6. 删除指定下标索引的元素（2种方式）
mylist = ["itcast", "itheima", "python"]# 6.1 方式1：del 列表[下标] mylist 方法
del mylist[2]
print(f"列表删除元素后结果是：{mylist}")
# 结果：列表删除元素后结果是：['itcast', 'itheima']# 6.2 方式2：列表.pop(下标)
mylist = ["itcast", "itheima", "python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容：{mylist}, 取出的元素是：{element}")
# 结果：通过pop方法取出元素后列表内容：['itcast', 'itheima'], 取出的元素是：python# 7. 删除某元素在列表中的第一个匹配项 remove 方法
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
mylist.remove("itheima")
print(f"通过remove方法移除元素后，列表的结果是：{mylist}")
# 结果：通过remove方法移除元素后，列表的结果是：['itcast', 'itcast', 'itheima', 'python']# 8. 清空列表 clear 方法
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")
# 结果：列表被清空了，结果是：[]# 9. 统计列表内某元素的数量 count方法
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
count = mylist.count("itheima")
print(f"列表中itheima的数量是：{count}")
# 结果：列表中itheima的数量是：2# 10. 统计列表中全部的元素数量 len
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
count = len(mylist)
print(f"列表的元素数量总共有：{count}个")
# 结果：列表的元素数量总共有：5个

使用while和for循环遍历列表

def list_while_func():"""使用while循环遍历列表的演示函数:return: None"""mylist = ["学习", "程序员", "Python"]# 循环控制变量：通过下标索引来控制，默认是0# 每一次循环，将下标索引变量+1# 循环条件：下标索引变量 < 列表的元素数量# 定义一个变量，用来标记列表的下标index = 0       # 初始下标为0while index < len(mylist):# 通过index变量取出对应下标的元素element = mylist[index]print(f"列表的元素：{element}")# 至关重要：将循环变量（index）每一次循环都+1index += 1def list_for_func():"""使用for循环遍历列表的演示函数:return:"""mylist = [1, 2, 3, 4, 5]# for 临时变量 in 数据容器:for element in mylist:print(f"列表的元素有：{element}")if __name__ == '__main__':# list_while_func()list_for_func()

tuple元组的定义和操作。

# 定义元组
t1 = (1, "Hello", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)}, 内容是：{t1}")
print(f"t2的类型是：{type(t2)}, 内容是：{t2}")
print(f"t3的类型是：{type(t3)}, 内容是：{t3}")# 定义单个元素的元素
t4 = ("hello", )
print(f"t4的类型是：{type(t4)}, t4的内容是：{t4}")# 元组的嵌套
t5 = ( (1, 2, 3), (4, 5, 6) )
print(f"t5的类型是：{type(t5)}, 内容是：{t5}")# 下标索引去取出内容
num = t5[1][2]
print(f"从嵌套元组中取出的数据是：{num}")

tuple 元祖常用方法预览。元组不可修改，所以其操作方法非常少。

tuple 元祖的常用方法演示

# 元组的操作：index查找方法
t6 = ("java", "测试", "Python")
index = t6.index("Python")
print(f"在元组t6中查找python，的下标是：{index}")
# 结果：在元组t6中查找python，的下标是：2# 元组的操作：count统计方法
t7 = ("java", "vue", "vue", "vue", "Python")
num = t7.count("vue")
print(f"在元组t7中统计vue的数量有：{num}个")
# 结果：在元组t7中统计vue的数量有：3个# 元组的操作：len函数统计元组元素数量
t8 = ("java", "vue", "vue", "vue", "Python")
num = len(t8)
print(f"t8元组中的元素有：{num}个")
# 结果：t8元组中的元素有：5个

元组的遍历

# 元组的遍历：while
index = 0
while index < len(t8):print(f"元组的元素有：{t8[index]}")# 至关重要index += 1# 元组的遍历：for
for element in t8:print(f"2元组的元素有：{element}")

字符串常用方法汇总

字符串常用方法演示

# 定义集合
my_set = {"java", "vue", "itheima", "java", "vue", "itheima", "java", "vue", "itheima"}
my_set_empty = set()        # 定义空集合
print(f"my_set的内容是：{my_set}, 类型是：{type(my_set)}")
#结果：my_set的内容是：{'java', 'itheima', 'vue'}, 类型是：<class 'set'>
print(f"my_set_empty的内容是：{my_set_empty}, 类型是：{type(my_set_empty)}")
#结果：my_set_empty的内容是：set(), 类型是：<class 'set'># 添加新元素
my_set.add("Python")
my_set.add("java")      #
print(f"my_set添加元素后结果是：{my_set}")
#结果：my_set添加元素后结果是：{'Python', 'java', 'itheima', 'vue'}# 移除元素
my_set.remove("vue")
print(f"my_set移除vue后，结果是：{my_set}")
#结果：my_set移除vue后，结果是：{'Python', 'java', 'itheima'}# 随机取出一个元素
my_set = {"java", "vue", "itheima"}
element = my_set.pop()
print(f"集合被取出元素是：{element}, 取出元素后：{my_set}")
#结果：集合被取出元素是：java, 取出元素后：{'itheima', 'vue'}# 清空集合, clear
my_set.clear()
print(f"集合被清空啦，结果是：{my_set}")
#结果：集合被清空啦，结果是：set()# 取2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
#结果：取出差集后的结果是：{2, 3}
print(f"取差集后，原有set1的内容：{set1}")
#结果：取差集后，原有set1的内容：{1, 2, 3}
print(f"取差集后，原有set2的内容：{set2}")
#结果：取差集后，原有set2的内容：{1, 5, 6}# 消除2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后，集合1结果：{set1}")
#结果：消除差集后，集合1结果：{2, 3}
print(f"消除差集后，集合2结果：{set2}")
#结果：消除差集后，集合2结果：{1, 5, 6}# 2个集合合并为1个
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"2集合合并结果：{set3}")
#结果：2集合合并结果：{1, 2, 3, 5, 6}
print(f"合并后集合1：{set1}")
#结果：合并后集合1：{1, 2, 3}
print(f"合并后集合2：{set2}")
#结果：合并后集合2：{1, 5, 6}# 统计集合元素数量len()
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(f"集合内的元素数量有：{num}个")
#结果：集合内的元素数量有：5个

集合的遍历

# 集合不支持下标索引，不能用while循环
# 可以用for循环
set1 = {1, 2, 3, 4, 5}
for element in set1:print(f"集合的元素有：{element}")
#结果：集合的元素有：1
#结果：集合的元素有：2
#结果：集合的元素有：3
#结果：集合的元素有：4
#结果：集合的元素有：5

数据容器字典的定义

# 定义字典
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是：{my_dict1}, 类型：{type(my_dict1)}")
print(f"字典2的内容是：{my_dict2}, 类型：{type(my_dict2)}")
print(f"字典3的内容是：{my_dict3}, 类型：{type(my_dict3)}")# 定义重复Key的字典
my_dict1 = {"王力鸿": 99, "王力鸿": 88, "林俊节": 77}
print(f"重复key的字典的内容是：{my_dict1}")# 从字典中基于Key获取Value
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
score = my_dict1["王力鸿"]
print(f"王力鸿的考试分数是：{score}")
score = my_dict1["周杰轮"]
print(f"周杰轮的考试分数是：{score}")
# 定义嵌套字典
stu_score_dict = {"王力鸿": {"语文": 77,"数学": 66,"英语": 33}, "周杰轮": {"语文": 88,"数学": 86,"英语": 55}, "林俊节": {"语文": 99,"数学": 96,"英语": 66}
}
print(f"学生的考试信息是：{stu_score_dict}")# 从嵌套字典中获取数据
# 看一下周杰轮的语文信息
score = stu_score_dict["周杰轮"]["语文"]
print(f"周杰轮的语文分数是：{score}")
score = stu_score_dict["林俊节"]["英语"]
print(f"林俊节的英语分数是：{score}")

字典常用方法汇总

字典常用方法演示

my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
# 新增元素
my_dict["张信哲"] = 66
print(f"字典经过新增元素后，结果：{my_dict}")
#结果：字典经过新增元素后，结果：{'周杰轮': 99, '林俊节': 88, '张学油': 77, '张信哲': 66}# 更新元素
my_dict["周杰轮"] = 33
print(f"字典经过更新后，结果：{my_dict}")
#结果：字典经过更新后，结果：{'周杰轮': 33, '林俊节': 88, '张学油': 77, '张信哲': 66}# 删除元素
score = my_dict.pop("周杰轮")
print(f"字典中被移除了一个元素，结果：{my_dict}, 周杰轮的考试分数是：{score}")
#结果：字典中被移除了一个元素，结果：{'林俊节': 88, '张学油': 77, '张信哲': 66}, 周杰轮的考试分数是：33# 清空元素, clear
my_dict.clear()
print(f"字典被清空了，内容是：{my_dict}")
#结果：字典被清空了，内容是：{}# 获取全部的key
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")
#结果：字典的全部keys是：dict_keys(['周杰轮', '林俊节', '张学油'])# 统计字典内的元素数量, len()函数
num = len(my_dict)
print(f"字典中的元素数量有：{num}个")
#结果：字典中的元素数量有：3个

遍历字典

# 方式1：通过获取到全部的key来完成遍历
for key in keys:print(f"字典的key是:{key}")print(f"字典的value是：{my_dict[key]}")# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:print(f"2字典的key是:{key}")print(f"2字典的value是：{my_dict[key]}")

数据容器的通用功能

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}# len元素个数
print(f"列表 元素个数有：{len(my_list)}")
print(f"元组 元素个数有：{len(my_tuple)}")
print(f"字符串元素个数有：{len(my_str)}")
print(f"集合 元素个数有：{len(my_set)}")
print(f"字典 元素个数有：{len(my_dict)}")# max最大元素
print(f"列表 最大的元素是：{max(my_list)}")
print(f"元组 最大的元素是：{max(my_tuple)}")
print(f"字符串最大的元素是：{max(my_str)}")
print(f"集合 最大的元素是：{max(my_set)}")
print(f"字典 最大的元素是：{max(my_dict)}")# min最小元素
print(f"列表 最小的元素是：{min(my_list)}")
print(f"元组 最小的元素是：{min(my_tuple)}")
print(f"字符串最小的元素是：{min(my_str)}")
print(f"集合 最小的元素是：{min(my_set)}")
print(f"字典 最小的元素是：{min(my_dict)}")# 类型转换: 容器转列表
print(f"列表转列表的结果是：{list(my_list)}")
print(f"元组转列表的结果是：{list(my_tuple)}")
print(f"字符串转列表结果是：{list(my_str)}")
print(f"集合转列表的结果是：{list(my_set)}")
print(f"字典转列表的结果是：{list(my_dict)}")# 类型转换: 容器转元组
print(f"列表转元组的结果是：{tuple(my_list)}")
print(f"元组转元组的结果是：{tuple(my_tuple)}")
print(f"字符串转元组结果是：{tuple(my_str)}")
print(f"集合转元组的结果是：{tuple(my_set)}")
print(f"字典转元组的结果是：{tuple(my_dict)}")# 类型转换: 容器转字符串
print(f"列表转字符串的结果是：{str(my_list)}")
print(f"元组转字符串的结果是：{str(my_tuple)}")
print(f"字符串转字符串结果是：{str(my_str)}")
print(f"集合转字符串的结果是：{str(my_set)}")
print(f"字典转字符串的结果是：{str(my_dict)}")# 类型转换: 容器转集合
print(f"列表转集合的结果是：{set(my_list)}")
print(f"元组转集合的结果是：{set(my_tuple)}")
print(f"字符串转集合结果是：{set(my_str)}")
print(f"集合转集合的结果是：{set(my_set)}")
print(f"字典转集合的结果是：{set(my_dict)}")# 进行容器的排序 sorted
my_list = [3, 1, 2, 5, 4]
my_tuple = (3, 1, 2, 5, 4)
my_str = "bdcefga"
my_set = {3, 1, 2, 5, 4}
my_dict = {"key3": 1, "key1": 2, "key2": 3, "key5": 4, "key4": 5}print(f"列表对象的排序结果：{sorted(my_list)}")
print(f"元组对象的排序结果：{sorted(my_tuple)}")
print(f"字符串对象的排序结果：{sorted(my_str)}")
print(f"集合对象的排序结果：{sorted(my_set)}")
print(f"字典对象的排序结果：{sorted(my_dict)}")print(f"列表对象的反向排序结果：{sorted(my_list, reverse=True)}")
print(f"元组对象的反向排序结果：{sorted(my_tuple, reverse=True)}")
print(f"字符串对象反向的排序结果：{sorted(my_str, reverse=True)}")
print(f"集合对象的反向排序结果：{sorted(my_set, reverse=True)}")
print(f"字典对象的反向排序结果：{sorted(my_dict, reverse=True)}")

字符串大小比较

# abc 比较 abd
print(f"abd大于abc，结果：{'abd' > 'abc'}")
# a 比较 ab
print(f"ab大于a，结果：{'ab' > 'a'}")
# a 比较 A
print(f"a 大于 A，结果：{'a' > 'A'}")
# key1 比较 key2
print(f"key2 > key1，结果：{'key2' > 'key1'}")

文件操作功能汇总

打开文件中 mode参数常用三种访问形式

文件打开 open

# 打开文件
import timef = open("D:/测试.txt", "r", encoding="UTF-8")
print(type(f))
# 读取文件 - read()
# print(f"读取10个字节的结果：{f.read(10)}")
# print(f"read方法读取全部内容的结果是：{f.read()}")
print("-----------------------------------------------")
# 读取文件 - readLines()
# lines = f.readlines()   # 读取文件的全部行，封装到列表中
# print(f"lines对象的类型：{type(lines)}")
# print(f"lines对象的内容是：{lines}")# 读取文件 - readline()
# line1 = f.readline()
# line2 = f.readline()
# line3 = f.readline()
# print(f"第一行数据是：{line1}")
# print(f"第二行数据是：{line2}")
# print(f"第三行数据是：{line3}")# for循环读取文件行
# for line in f:
#     print(f"每一行数据是:{line}")
# # 文件的关闭
# f.close()
# time.sleep(500000)
# with open 语法操作文件
with open("D:/测试.txt", "r", encoding="UTF-8") as f:for line in f:print(f"每一行数据是：{line}")time.sleep(500000)

文件写入 write

# 打开文件，不存在的文件, r, w, a
import time# f = open("D:/test.txt", "w", encoding="UTF-8")
# # write写入
# f.write("Hello World!!!")       # 内容写入到内存中
# # flush刷新
# # f.flush()                       # 将内存中积攒的内容，写入到硬盘的文件中
# # close关闭
# f.close()                       # close方法，内置了flush的功能的
# 打开一个存在的文件
f = open("D:/test.txt", "w", encoding="UTF-8")
# write写入、flush刷新
f.write("python")
# close关闭
f.close()

文件的追加写入

# 打开文件，不存在的文件
# f = open("D:/test.txt", "a", encoding="UTF-8")
# # write写入
# f.write("python")
# # flush刷新
# f.flush()
# # close关闭
# f.close()
# 打开一个存在的文件
f = open("D:/test.txt", "a", encoding="UTF-8")
# write写入、flush刷新
f.write("\n月薪过万")
# close关闭
f.close()

捕获异常语法 try excepet finally

# 捕获所有异常
try:f = open("D:/123.txt", "r", encoding="UTF-8")
except Exception as e:print("出现异常了")f = open("D:/123.txt", "w", encoding="UTF-8")
else:print("好高兴，没有异常。")
finally:print("我是finally，有没有异常我都要执行")f.close()

Python 入门基础相关推荐

python笔记基础-Python入门基础知识学习笔记之一
为什么要写这篇文章? 本人做过Objective-C开发,现在在用C#做WinForm开发.近段时间在学习Python入门基础知识时,发现有很多知识点和Objective-C的不一样.故想通过本文记录 ...
python入门基础代码初学
python入门基础代码初学一.检查python安装二.print使用二.使用python运算三.enumerate()函数一.检查python安装 PS C:\Users\admin> ...
【目录】Python 入门基础篇＜（＾－＾）＞
Python 入门基础篇一.关于Python的介绍与准备工作 Python基础介绍 Jupyter notebook基础介绍 Jupyter notebook打开问题 Jupyter noteboo ...
Python入门基础知识学什么?
Python基础知识主要是针对一些零基础的同学安排的,虽说Python是相对比较简单的一门编程语言,但是没有基础的同学还是要进行系统的学习,那么Python入门基础知识学什么呢?来看看下面小编的详细介 ...
python 判断列表所有元素是否为某个值_这应该是最详细的Python入门基础语法总结！...
这应该是最详细的Python入门基础语法总结! 这应该是最详细的Python入门基础语法总结! 定义变量,使用变量 input 用户自己输入值 print 打印值可以输出多个变量 %d|%s 用于输 ...
python入门基础教程-Python入门基础教程：WSGI
原标题:Python入门基础教程:WSGI WSGI 简介 WSGI 是什么 WSGI 是 Python Web Server Gateway Interface 的缩写,是描述 Web 服务器与 P ...
Python入门基础总结笔记——正则表达式
Python入门基础总结笔记--正则表达式完整基础知识参看网站:正则表达式总结重点用\d可以匹配一个数字,\w可以匹配一个字母或数字用*表示任意个字符(包括0个),用+表示至少一个字符用?表 ...
B站马士兵python入门基础版详细笔记（6）
前言: 这篇文章是B站学习python入门基础班的视频的第五六章内容,主要讲述的是列表,主要包括列表的创建,以及他的元素的增.删.查.改操作命令. 一.列表的初始化为什么要使用列表? 列表就好比C ...
Python入门基础（下）之魔方方法
Python入门基础(下)之魔方方法一.学习内容概括学习地址:https://tianchi.aliyun.com/s/58327c15d1faee512c008128d3bb9e32 今天主要学 ...
B站马士兵python入门基础版详细笔记（4）
前言: 这篇文章是B站学习python入门基础班的视频的第四章内容,主要讲述的是if-else语句,但是不包括循环结构,循环结构在下一章笔记中有记叙一.顺序结构什么是顺序结构呢?比如说 '''把大 ...

Python 入门基础

Python 入门基础相关推荐

最新文章

热门文章