Python程序设计
字面量：
数值类型：整数，浮点数，复数，布尔值
print("Hello,World!")
print("666")
注释
#单行注释：以 **# ** 开头
# printf("jinitaimei")
#多行注释：一对三引号""" """
"""
printf("ji")
"""
变量
#变量名称=变量的值
i=666.666
s="Hello,World!"
i-=10
print(i)
print(s)
数据类型
字符串类型,整数类型，浮点数类型
type()(查看类型)
i=66.66
type(i)
# <class 'float'>
数据类型转换
int(x)
float(x)
str(x)
字符串扩展
单引号定义：name='鸡你太美'
双引号定义：name="就你太美"
三引号定义：name=""" 鸡鸡 """
包含引号：name='"ji"'
使用转义号\解除引号效用
name="\"ji\""
字符串拼接
print("ji"+"ni"+"tai"+"mei")
字符串格式化
name="ji"
jjjj="%s tai mei%d %.5f"%(name,1,10.1)
print(f"{name} ni tai mei")
print(jjjj)
# 精度
# %.5f 和c一样
对表达式进行格式化
print("%d ni tai mei"%(1*1))
(1**x)1的x次方
输入
print("Who are you?")
name=input()
print("Hello,%s"%name)
判断
bool值
true 真
false 假
比较运算符和c一样
== != >= <= > <
if语句基本格式
if 条件:
语句
else:
语句
cxk=input("请输入：")
if cxk=="鸡":
print("你干嘛~~哎呦~~~")
print("ji ji ji ji")#有缩进就表示小于上一级
else:
print("蔡先生不是鸡，各位荔枝一点")# 不成立语句
if语句连接
if 条件1:
语句
elif 条件 2:
语句
else :
语句
if语句嵌套
if 条件:
语句
if 条件:
语句
else ：
语句
else:
语句
随机数
import random
num =random.randint(1,10)
循环
while :
语句1;
语句2;
# 1~100的和
a=0
sum=0
while a<101:
sum+=a
a+=1
print(sum)
while嵌套
while ji:
jjjj
while jiji:
jiji
i=0
while i<100:
print("I love 油饼")
j = 0
while j<10:
print("我食")
j+=1
i += 1
# 九九乘法表
i=1
while i<=9:
j = 1
while j<=i:
print("%s * %s = %-4s"%(j,i,i*j),end=' ')
j+=1
print("")
i += 1
end=’ '表示结尾不换行
for循环
遍历字符串
name="ji ni tai mei"
for x in name:
print(x)
range语句(配合for循环使用)
range(a)输出0到a-1
range(a，b)输出a到b-1
range(a，b，k)输出a到b-1，跨度为k
n=10
for x in range(n):
print(x)
for变量域
临时变量作用域
for x in range(10):
printf(x)
printf(x)
# 可以正常访问，但不规范
for嵌套
for x in range(1,10):
for y in range(1,10):
print("%s * %s = %-4s"%(y,x,x*y),end=' ')
print("")
循环中断和跳出continue和break
for i in range(1,10):
print("ji")
if i!=9 :
continue
if i==9:
for j in range(1,5):
printf("cxk")
函数
有一些内置函数可以直接使用
cxk="ji ni tai mei"
cnt=0
n=len(cxk)
print(n)
def my_len(data):
cnt=0
for i in data:
cnt += 1
print(cnt)
my_len(cxk)
a=5
b=6
ma=max(a,b)
print(ma)
函数的定义
def name(data):
do
return 0
def swap(x,y):
temp=x
x=y
y=temp
print("交换之后的值为%d和%d"%(x,y))
a=1
b=0
print("交换之前的值为%d和%d"%(a,b))
swap(a,b)
None
表示空
def ji(j):
return None
name=None
函数的嵌套调用
def a():
print("ji")
def b(x):
a()
print("ni")
b(1)
全局变量
global声明这个变量是一个全局变量
num=100
def a():
print(num)
def b():
global num
num=100
print(num)
a()
b()
print(num)
数据容器
列表（list）
#字面量
[1,2,3,4,5]
#定义变量
变量名称=[1,2,3,4,5]
#定义空列表
变量名称=[]
变量名称=list()
#基础列表
ji=[1,lll,ture,六]
#列表嵌套
ji=[[1,2,3],[4,5,6]]
列表的下标索引
从前往后0开始，从后往前-1减1
ji=[[1,2,3],[4,5,6]]
列表操作
查找下标
语法：list.index(元素)
j=[1,2,3,4,5,6]
index=j.index(6)
插入新元素
语法：list.insert(下标，元素)
j=[1,2,3,4,5,6]
j.insert(6,7)
追加元素
语法：list.append(元素)加到末尾
j=[1,2,3,4,5,6]
j.append(6,7)
追加元素2
语法：list.extend(list)依次加到末尾
j=[1,2,3,4,5,6]
ji=[7,8,9]
j.extend(ji)
删除元素
语法1：del list[0]
语法2: list.pop(0)
j=['j','j','j','n','t','m']
del j[0]
j.pop(0)
删除某元素的第一个匹配项
语法：list.remove(元素)
j=['j','j','j','n','t','m']
j.remove(j)
清空列表
语法：list.clear()
统计某元素在列表中的数量
语法: list.count(元素)
j=['j','j','j','n','t','m']
print(j.count('j'))
j.clear()
print(j)
统计全部数量
语法：len(list)
列表的遍历
index=0
while index<len(list):
元素=list[index]
index+=1
for x in list:
print(x)
元组
元组一旦定义完成，就不可修改
#字面量
(1,2,3,4)
#定义变量
变量名称=(1,2,3,4,5)
#定义空元组
变量名称=()
变量名称=tuple()
#基础元组
ji=(1,2,3,4,5,"六六六")
#元组嵌套
ji=ji=((1,2),(2,3))
元组操作
tuple.index()查找下标
tuple.count()统计某元素在元组中的数量
len(元组)统计全部数量
元组的遍历
index=0
ji=(1,2,3,4,5)
while index<len(ji):
print(index)
index+=1
for x in ji:
print(x)
字符串定义和操作
字符串无法修改
查找特定字符串下标索引值
语法：str.index(str)
name="ji ni tai mei"
print(name.index("mei"))
字符串的替换
语法：str.replace(str1,str2)
将str中str1替换str2并赋值给新的str
j="j n t h"
ji=j.replace("h","m")
字符串的分割
语法：str.split(分隔符)
按照指定的分隔符分隔字符串，转化为列表
j="j n t h"
ji=j.split(" ")
字符串的规整操作
（去前后空格）
语法：str.strip()
（去前后指定字符串）
语法：str.strip(str)
j=" ji ji ji ji ji "
ji=j.strip()
print(j.strip())
print(ji.strip("ji"))
str.count(str)统计某元素在元组中的数量
len(len)统计长度
j=" ji ji ji ji ji "
print(j.count("ji"))
print(len(j))
数据容器的切片操作
序列：内容连续，有序，可以使用下标索引
序列支持切片操作
切片：从一个序列中取出一个一个子序列
语法;序列[起始下标：结束下标：步长]
起始下标可以留空，从头开始，结束下标同理
步长：N表示每次跳过N-1个元素，为负数反向取（起始和结束下标也要反向标记）
操作不会影响序列本身，因为序列中元组和字符串不可修改
ji=[1,2,3,4,5,6,7,8,8,9,0]
cxk="jjii nnii ttaaii mmeeii"
list=ji[1:5:1]
str=cxk[::2]
集合
#字面量
{1,2,3,4}
#定义变量
变量名称={1,2,3,4}
#定义空集合
变量名称=set()
#基础集合
ji=(1,2,3,4,5,"六六六")
#元组嵌套
ji=ji=((1,2),(2,3))
集合无序，不支持下标索引访问但允许修改
添加新元素
语法：set.add(data)
移除新元素
语法：set.remove(data)
随机取出一个元素同时原集合中会消失
语法：set2=set.pop()
ji={14,2,3,'j',4,"ji","jjjjj"}
ji.add("ji ni tai mei")
ji.remove("ji")
jj=ji.pop()
清空集合
语法：set.clear()
取两个集合的差集（1中有而2中没有的元素）
语法：set3=set1.difference(set2)
消除差集（删除1中和2 相同的部分）
语法：set3=set1.difference_update(set2)
合并两个集合
语法：set3=set1.union(set2)
统计集合数量
语法：len(set)
jii={1,2}
ji={14,2,3,'j',4,"ji","jjjjj"}
jj={14,2,3,4}
jiji={"ji","ni"}
jijiji={"tai","mei"}
jii.clear()
cxk=ji.difference(jj)
ji.difference_update(jj)
ji=jiji.union(jijiji)
print(ji)
set1={1,2,3,4,5}
print(len(set1))
集合的遍历
用for循环
set1={1,2,3,4,5}
for x in set1:
print(x)
字典
#定义字典字面量
{key:value,key:value,key:value,key:value}
#定义字典变量
变量名称={key:value,key:value,key:value,key:value}
#定义空字典
变量名称={}
变量名称=dict()
#基础集合
ji=(1,2,3,4,5,"六六六")
#元组嵌套
ji=ji=((1,2),(2,3))
ji={"ji":1,"cxk":"mei"}
print(ji["cxk"])
嵌套字典
my_dict={
"荔枝":{
"j":"你干嘛~~哎呦~~",
"n":"你实在是太美"
},"油饼":{
"t":"迎面走来的你让我如此蠢蠢欲动",
"m":"我食我食"
},"苏珊":{
"cxk":"小黑子什么意思，速删",
"鸡":"你们上过学吗？"
}
}
print(f"ji 实在是太美\n{my_dict}")
print(my_dict["荔枝"]["j"])
字典操作
新增元素
语法：dict[key]=value ,结果：字典被修改，新增了元素
更新元素
语法：dict[key]=value ,更新value的值
my_dict={
"荔枝":{
"j":"你干嘛~~哎呦~~",
"n":"你实在是太美"
},"油饼":{
"t":"迎面走来的你让我如此蠢蠢欲动",
"m":"我食我食"
},"苏珊":{
"cxk":"小黑子什么意思，速删",
"鸡":"你们上过学吗？"
}
}
my_dict["油饼"]["t"]="食不食油饼"
mi_dict["ji"]="想进监狱？"
删除元素
语法：dict.pop(key)
清空元素
语法： dict.clear()
获取全部的key
语法 ：kes=dict.keys()
遍历字典
语法：for key in dict:
print(dict[key])
统计字典中元素数量
语法：num=len(dict)
my_dict={
"荔枝":{
"j":"你干嘛~~哎呦~~",
"n":"你实在是太美"
},"油饼":{
"t":"迎面走来的你让我如此蠢蠢欲动",
"m":"我食我食"
},"苏珊":{
"cxk":"小黑子什么意思，速删",
"鸡":"你们上过学吗？"
}
}
my_dict["油饼"]["t"]="食不食油饼"
my_dict["ji"]="想进监狱？"
my_dict.pop("ji")
kes=my_dict["荔枝"].keys()
keys=my_dict.keys()
print(my_dict)
print(kes)
num=len(my_dict)
print(num)
for key in my_dict:
print(my_dict[key])
数据容器的通用操作
容器的通用排序功能
语法：sorted(list,reverse=True))默认是false，true是反向
ji=[1,3,2,7,4,32,4]
print(sorted(ji))
print(sorted(ji,reverse=True))
排序结果全变成列表了，对内容排序放入列表中
函数进阶
函数的多个返回值
def ji():
return 1,2,"cxk"
x,y,z=ji()
函数的传参方式
关键字传参：
缺省参数
不定长参数
def cxk(age,time,name='蔡'):
print(f"{name}先生,你的年龄是{age},练习时间是{time}呢")
ji=cxk(age=25,time="两年半",name="蔡徐坤")
boy1=cxk(18,"2 years",)
def cx(*age):
print(age)
ji=cx("cxk","你干嘛~~",666)
def c(**xxx):
print(xxx)
ji=c(name=15,ji="cxk")
匿名函数
函数作为参数传递
lambda函数
def ji(x):
c=x(9,9)
print(c)
ji(lambda x,y:x*y)
文件操作
文件编码
UTF-8是全球通用的文件编码
文件的读取
open函数：
读取文件-read()
f=open( "D:/test.txt","r",encoding="UTF-8")
print(type(f))#文件的打开
#文件的读取
#read
print(f"结果：{f.read(20)}")
print(f"结果：{f.read()}")#多次调用read，会从上一次结尾开始
读取全部文件，封装到列表中
f=open( "D:/test.txt","r",encoding="UTF-8")
print(type(f))#文件的打开
#readLines()读取文件全部行，封装到列表中
lines =f.readlines()
# print(lines)已经被读取完、
读操作相关方法
readline()：一次读取一行内容转为字符串
# line1=f.readline()
# print(line1)
# print(type(line1))
# line2=f.readline()
# print(line2)
# line3=f.readline()
# print(line3)
for循环读取文件行
f=open( "D:/test.txt","r",encoding="UTF-8")
print(type(f))#文件的打开
for line in f:
print(line)
文件的关闭
file.close
时间函数
import time
time.sleep(3)
with open
可以自己关掉文件
with open("D:/test.txt","r",encoding="UTF-8") as ff:
for linn in ff:
print(linn)
总结
文件的写入
#打开文件
f=open("D:/test.txt","w")
#文件写入
f.write("Hello,World!")
#文件更新
f.flush()
文件的追加操作
#打开文件
f=open("D:/test.txt","a")
#文件写入
f.write("Hello,World!")
#文件更新
f.flush()
919
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
