python笔记
数据类型查看
-
使用 type（）语句来查看数据的类型
-
方法一：使用print直接输出信息
print(type（"黑马程序员") print(type("666")) print(type(11.345))- 方法二：使用变量存储type（）语句的结果
string-type=type("黑马程序员”) int-type=type(666) float-type=type(11.345) print(string-type)- 方法三：使用type（）语句，查看变量中的数据类型
name='黑马程序员' name-type=type(name) print(name-type)- 变量没有类型，但是变量所存储的数据有类型
字符串的定义方式
- 单引号
- 双引号
- 三个双引号
字符串格式化
字符串和变量的快速拼接
name = "黑马程序员"
message ="学IT就来 %s" % name
print(message)
则输出"学IT就来黑马程序员"
- % 表示:占位
- s 表示:将变量放入占位的地方
| 格式符号 | 转化 |
|---|---|
| %s | 将内容转化为字符串 |
| %d | 将内容转化为整数 |
| %f | 将内容转化为浮点型,放入占位位置 |
剩下的不再赘述
格式化字符串的过程中的精度控制
与c语言一致,通过"m.n"来控制精度
- 约束条件:m,控制总体的宽度(宽度小于数字本身,无效)
- 限制条件:n,控制小数点精度,要求是数字,会进行四舍五入
num1=11
num2=11.345
print("数字11宽度限制5,结果是:%5d" %num1)
print("数字11宽度限制1,结果是:%1d" % num1)
print("数字11.345宽度限制7,小数精度2,结果是%7.2f" % num2)
print("数字11.345不限制,小数精度2,结果是 :%.2f" % num2)
字符串格式方法2
通过语法：f"内容{变量}“的格式；来快速格式化
下面是例子：
name = "田文哲"
birthday = "0151561"
print(f"我是{name}，我生于{birthday}")
注：
- 不会理会类型
- 不会控制精度
适合对精度没有要求时的快速使用
对表达式进行字符串格式化
print(f"1*1的结果是{1*1}")
{1*1}的结果直接输出出来
其他格式化方法同样适用
股票报价小程序
name = "无忧传媒"
stock_price = 21#"当前票价"
stock_code = 12#"股票代码"
stock_price_daily_growth_factor = 1.2#股票每日增长系数
growth_days = 7#股票涨了多少天
print(f"公司{name}，股票代码{stock_code},当前票价{stock_price}")
print("每日增长系数：%f，经过%d天的增长后，股价达到了：%.2f"%(stock_price_daily_growth_factor,growth_days,stock_price*stock_price_daily_growth_factor**growth_days))
input语句
name = input("请输入你的名字")
注意：input语句输入的默认为字符串类型
可以
num = int(input("请输入整数"))
来进行解决
常见的6种数据类型
布尔类型
result = 10>5
print(result)
则输出结果为1
not
非的意思
运算符
==等于
！=不等
>
<
>=
<=
if语句
不同于c语言，python的if的多行语句不是通过{}来实现，而是通过对应相同的空格缩进来实现！！！
num = 1
if num = 1：
print(num) #注意首行缩进四个空格
if--elif--else
与c语言不同，python通过elif来实现第一个条件不满足时接下来的条件判断
height = int(input("请输入你的身高(cm)"))
vip_level= int(input("请输入你的vip等级（1-5）"))
if height<120:
print("身高小于120，随便玩")
elif vip_level>3
print("高级用户，免费游玩")
else
("需要买票10元")
也可以直接
if int(input("请输入您的身高"))<120
print("身高小于120，随便玩")
if的嵌套
if 条件1:
if嵌套条件1:
嵌套层执行语句
else：
嵌套层执行语句
else：
最外层执行语句
while循环
猜随机数字例子
mport random
num = random.randint(1,100)
while 1:
a = int(input("请输入一个1~100的数"))
if a==num:
print("恭喜你猜对了")
break
else:
if a>num:
print("你猜大了")
else:
print("你猜小了")
print(num)
print("请再猜一次")
break同样也可以使用
同样可以通过修改变量方式来实现bool类型改变
fiag = Ture
while flag:
if a==num:
print("恭喜你猜对了")
flag = False
else:
print(num)
综合案例：发工资
#注，可以在逗号后面加个空格
i = 1
all_wage = 10000
while i < 21:
import random
num = random.randint(1, 10)
if all_wage >= 1000 :
if num < 5:
print(f"员工{i}，绩效分{num}，不发工资，下一位")
else:
all_wage = all_wage - 1000
print(f"向员工{i}发放工资1000元，账户余额还有{all_wage}元")
i += 1
else :
print("工资已发完，下个月再领")
break
for循环
基本语法格式
for 临时变量 in 待处理数据(序列)：
循环满足条件时执行的代码
注：无法定义循环条件，只能被动取出数据处理
注：有对应的空格缩进
就是将待处理数据中的值一一赋给临时变量
eg.数单词中几个a
count = 0
for x in namea
if x =="a"#注意别落了""
count +=1
print(f"被统计的字符串中共有{count}个a")
range语句
获得一个简单的数字序列
range(num)
获得从零开始，到num结束的序列，不含num本身
eg. range(5)：[0,1,2,3,4]
range(num1,num2)
从num1开始，到num2结束
eg.range(5,10):[5,6,7,8,9]
range(num1,num2,step)
从num1开始，到num2结束，步长为step
for循环临时变量作用域
临时变量在规范上无法被外部给捕捉,即在for循环中的变量无法在外部给输出
for循环嵌套
for i in range(1,101)
for j in range(10)
print("这就是for循环嵌套")
continue与break与c语言一致
函数
# 接下来是定义函数
#利用函数求字符串长度
str1 = "abcdr"
str2 = "djskfjsda"
# python自带的len()函数
print(len(str1))
print(len(str2))
# 下面是我自己定义的函数
def my_len(data):
count = 0
for i in data:
count += 1
print(f"字符串{data}的长度是{count}")
# 接下来就可以正常使用了
my_len(str1)
my_len(str2)
# 函数的定义： （其实与c语言类似）
# def 函数名 （传入参数）: 传入参数可以不写，但必须写括号 eg.test01()
# 函数体（空格缩进4字符）
# return 返回值
# 函数的调用
# 函数名（参数） 若函数中没有参数，则这个地方的参数可以不写
def check():
print("请出示72小时核酸隐性证明")
check()
def add(x, y, z): # x, y, z 我们称之为形参
result = x + y + z
print(result)
add(5, 9, 8) # 这，即函数调用中，我们称之为实参·
None
- 相当于c语言中的void
def 函数名 （函数参数）
函数体
上方没写返回值，则默认返回值就是None
当然，也可以写成return None - print（函数名） #输出的是返回值类型，没写则就是None
- type（函数名） #输出结果是<class'NoneType'>
- None等同于False
- if None： #就是如果是假的话
- None 可以用来赋无初始量的值
- eg. name = None
- 在之后的操作里,再给name赋值
函数的说明文档
对函数添加一个注释:
在输入三个双引号之后,会自动给你补全
def min(a, b):
"""
:param a:形参a的说明
:param b:形参b的说明
:return:返回值的说明
"""
函数体
return 返回值
函数的嵌套调用
def a():
print("1")
def b():
print("2")
a() # 调用a
print("3")
变量的作用域
注意区分全域变量与局部变量
def a()
num = 1
print(num) #这是不行的
global关键字
设置内部定义的变量为全局变量
def a()
global num =10
print(num)
有多个返回值：
def test_return():
return 1,2
x,y = test_return() #利用两个变量接收即可
print(x) #结果1
print(y) #结果2
变量之间用逗号隔开，
支持不同类型的数据return
函数的多种传参形式
位置参数
def max(a,b)
if ...
max(c,d) #找对应相应位置即可
关键字传参
函数调用时通过“键=值”的传参形式
可以让函数更清晰，容易使用，消除了位置需求
def user_info(name,age,gender)
print....
不按位置顺序
user_info(age = 20，gender=”男“，name = ”小明“)
可以与位置参数昏庸，位置参数必须在前，且匹配参数顺序
user_info("小明"，age = 20，gander=”男“)
缺省函数：
缺省函数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注：所有位置参数必须出现在默认参数前，包括函数的定义和调用）
def user_info(name,age,gender="男"):
print.....
user_info('Tom',20)
user_info('rose',18,'女') #不写就默认男
不定长参数
不定长参数也叫可变参数，用于不确定调用时的会传递多少个参数(不传参也可以)的场景
作用：当调用函数时不确定参数个数是，可以使用不定长参数
位置传递的不定长函数里接收多个变量 ，形成元组
规范书写：里面写args
def uset_info(*args):
print(args)
# ('Tom')
uset_info('Tom')
# ('Tom', 18)
uset_info('Tom', 18) #所有参数会被收集，并生成一个元组
关键字传递的不定长 接收多个变量，形成字典
书写规范：kwargs
def user_info(**kwargs):
print(wargs)
user_info(name='Tom', age=18,id=110)
函数作为参数传递
lambda匿名函数
- def定义函数，可重复调用
- lambda关键字，可定义匿名函数（无名称），只能临时使用一次
定义及用法
lambda 传入参数：仅能写一行的函数体
注：只能写一行代码，无法多行
eg.
上述图片代码就可以简化为
test_func(lambda x,y: x + y) #结果为3
方法
以函数为例：
在python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法
函数：
def add(x,y)
return x+y
方法：
class Student：
def add(self,x,y): return x + y
方法和函数功能一样，有传入参数，有返回值，只是使用方法不同
函数的使用： num = add(1,2)
方法的使用： student = Student()
num = student.add(1,2)
数据容器
通过一个变量储存多个数据，容纳的每一个数据被称之为一个元素，每一个元素，可以是任意类型，eg.字符串，数字，bool类型
list（列表）
列表定义
定义变量：变量名称 = [元素1，元素2，...]
字面量：[元素1，元素2，...]
定义空列表（两种方法：）
变量名称 = []
变量名称 = list[] #这是获取一个空列表
列表可以嵌套：
my_list = [[1,2,3],[4,5,6]]
print(my_list)
从列表中取出特定位置的元素
name_list = ['tom','lily','rose']
print(name_list[0])
print(name_list[1])
print(name_list[2])
或者，可以反向索引，也就是从后向前：从-1开始，依次递减（-1，-2，-3....）
即-1为最后一个元素
print(name_list[-1]) # rose
print(name_list[-2]) # lily
print(name_list[-3]) # tom
my_list = [[1,2,3],[4,5,6]] 索取对应元素时通过两层指引即可
my_list[1][1] #像是一个二维数组似的
列表的方法
列表内部提供了很多函数，有很多方法
-
查询功能
查找指定元素在列表的下标，如果找不到，报错
语法： 列表.index（元素）
my_list = ["itcast","itheima","python"]
index = mylist.index("itheima")
-
修改特定位置的值
与c类似，语法： 列表[下标] = 值
my_list[1] = 2 -
插入元素
语法：列表.insert(下标，元素)，在指定的下标位置，插入指定的元素,本来的这个下标位置的数，就变成下一个数了
my_list.insert（1,"best") -
追加元素
语法1：列表.append（元素），将指定元素，追加到列表尾部
语法2：列表.extend（其它数据容器），将其它数据容器的内容取出，依次追加到列表尾部 eg.my_list.extend(my_list2) -
删除元素
语法1： del my_list[2] #删除列表中第3个元素
语法2： 列表.pop（下标） #准确说这是取出元素，可以将其给到某个元素！
mylist = [1,2,3]
element = mylist.pop(2)
print(mylist)
-
删除某个元素在列表中的第一个匹配项
语法： 列表.remove（元素）
list1 = [1,2,3,2,4]
list1.remove(2)
print(list1) #结果： [1,3,2,3] -
清空列表
mylist.clear()
print(mylist) #结果[] -
统计某个元素在列表中的数量
list1 = [1,2,3,2,2,4]
i = list1.count(2) 拿变量i 接收这个数值
print(i) #结果为3 -
统计总共有多少个元素
语法： len（列表）
列表的遍历
将容器内的元素依次取出的行为，称之为：遍历、迭代
index = 0
while index < len(列表名)：
元素 = 列表[index]
对元素进行处理
index += 1
###元组 (tuple) 元组不可修改！
####定义
使用小括号，用逗号隔开各个元素，数据可以是不同的数据类型
~~~python
变量名称 = (元素，元素，....，元素)
#定义空元组
变量名称 = () #方式1
变量名称 = tuple() #方式2
# 定义1个元素的元组
t2 = ('hello','hello','hello',"nihao")
#元组的嵌套
t3 = ( (1, 2),(3, 4) )
注意：一个元素也要有逗号，否则不是元组类型
元组的方法
- 下标索引取出内容
t5 = ( (1, 2),(3, 4) )
num = t5[1][2]
print(f"索引内容为{num}") - index查找方法
a_find = t2.index("hello")
pirnt(a_find) - count统计方法
num = t3.count('hello') # 统计hello的数量 - len函数统计元素数量的总数
num = len(t2)
元组不可改，但在元组里嵌套列表，列表中的元素仍可修改
t7 = (1,2,['itma','5552'])
print(t7[2][1])
t7[2][1] = '2342'
print(t7[2][1])
字符串 不可修改
也是一种数据容器,与元组一样，是无法修改的容器
每个字母对应一个元素，也有对应下标索引
name = 'xiba'
print(name[1])
字符串的替换
字符串.replace(字符串1，字符串2)
功能： 将字符串的全部：字符串1，替换为字符串2
注意： 不是修改字符串本身，而是得到了一个新的字符串
new_my_str = str.replace("it","hema")
字符串的分割
语法： 字符串.split(分割字符串)
功能： 按照规定的分割字符串，将字符串划分为多个字符串，并存入列表对象中
注意： 字符串本身不变，而是得到了列表对象
my_str_list = my_str.split(" ") # 以空格作为分割
print(my_str_list,type(my_str_list))
my_str_list1 = my_str.replace(" ", "|") #把空格换成|
my_str_list2 = my_str_list1.split("|") #用|作为分割
print(my_str_list2) # 打印
字符串的规整操作(去句子首尾空格)
1.字符串.strip()
print(my_str.strip())
2.my_str = "21you and me12"
print(my_str.strip("12")) # 结果： “you and me”
==注意：传入的是“12”，其实就是：“1”和“2”都会被移除
统计字符串的长度 len()
num = len(my_str)
统计字符串中某字符串出现的次数
字符串.count("想要统计的字符串")
序列 可直接在其他操作上用
序列是指：内容连续，有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以视为序列
切片： 从一个序列中，取出一个子序列
语法： 序列[起始下标:结束下标:步长] 注：步长为负数表示，则起始下标和结束下标也要反过来，大的在前，小的在后
序列[:] # 都不写，表示从头到尾，步长为1可省略
# 以下是打印黑马程序员的操作
str3 = "万过薪月，员序程马黑来，nohtyp学"
# 倒叙字符串，切片取出
result1 = str3[::-1][9:14]
print(result1)
# 切片去除，然后倒叙
result2 = str3[5:10][::-1]
print(result2)
集合 元素不重复，且无序，不是序列
my_set = {"tan","tan","tan","tan","tan","djak"}
打印结果：
{"djak","tan"} # 本身会去重
添加新元素/移除元素
my_set.add("输入新添加的元素")
my_set.remove("输入要删除的元素")
随机取出元素
element = my_set.pop()
取出这个元素后，原集合就没有这个元素了
求集合的差集
语法： 集合1.difference(集合2)
功能：取出集合1有而集合2没有的元素
结果：得到一个新集合，集合1与集合2不变
消除2个集合的差集
语法：集合1.difference_update(集合2)
功能：在集合1中，删除和集合2相同的元素。
结果：集合1被修改，集合2不变
2个集合合并
语法：集合1.unior(集合2)
功能：将集合1与集合2合并组成新集合，原集合不变
set3 = set1.unior(集合2)
统计集合中元素个数 len()
见上
集合的遍历
因其无下标索引，所以不能用while循环，但可以用for循环
for element in set1
print(f"集合里的元素有{element}”)
、
字典 不支持下标索引，不能用while循环
作用原理：利用key来找到value
| key | value |
|---|---|
| 田文哲 | 100分 |
| 你 | 32分 |
| 他 | 23分 |
定义：
my_dict = {key:value,key:value,......,key:value}
my_dict = {"田文哲":100，"你":23}
空字典：
- my_dict = {}
- my_dict = dict{}
使用：
score = my_dict{"田文哲"}
print("田文哲得分是{score}")
字典的嵌套
注意：key 不能为字典
stu_score_dict = {
"田文哲":{"语文"：100,"数学101"}，"ni":{"语文":0,"数学":0}
}
获取数据print(stu_score_dict["田文哲"]["语文"])
字典的常用操作
- 新增/修改元素
语法： 字典[key] = value, 当key值不存在时，就等于新添加了元素，有对应key值，则就是修改了value - 删除元素
字典名.pop(key)，结果：获取指定key的value，同时更是字典被修改，指定key的而数据被删除，用一个新变量接收这个数据 - 清空字典
字典名.clear() - 获取全部的key
keys = my_dict.keys()
print(keys) - 字典的遍历
-- 法1
print(f"字典的key是：{key}")
print(f"字典的value是：{my_dict[key]}" )
-- 法2
for key in my_dict:
print(f"字典的key是：{key}")
print(f"字典的value是：{my_dict[key]}" ) - 统计元素数量
num = len(my_dict)
数据容器的普遍操作：
- len(容器) 统计元素个数
- max(容器) 统计容器的最大元素
- min(容器) 统计容器的最小元素
除了上述共性之外，还有：
- list(容器) 将给定容器转换为列表
- str() 将给定容器转换为字符串
- tuple(容器) 将给定容器转换为元组
- set(容器) 将给定容器转换为集合
字典转元组的结果是：只保留key，抛弃value
转字符串就保留value了
还有
sorted(容器) 从小到大排序，并放入列表当中
sorted(容器，reverse = True) 从大到小排序，并放入列表当中
字符串比大小
"dasfsdaf" <"fdsafsdaf" #返回值是 Ture 或者 False
利用ascii码表比较
文件的读取
f = open("D:\pythonProject12\测试.txt.txt", "r", encoding="UTF-8")
f1 = open("D:\pythonProject12\测试.txt.txt", "r", encoding="UTF-8")
f2 = open("D:\pythonProject12\测试.txt.txt", "r", encoding="UTF-8")
print(type(f)) # 输出结果文件类型是：对文本文件进行IO操作功能的一个类
# 读取文件 利用变量名所存的文件，加上 .read(这输入你想读取的字节) 下面是例子
print(f"读取全部字节的结果：{f.read()}")
# 值得注意的是：下一个read函数，接着上一个read函数的末尾开始的 你看：下面就已经是没有内容了
print(f"读取全部字节的结果：{f.read()}")
lines = f1.readlines() # 读取文件的全部行，封装到列表中
print(f"d读取全部行的结果：{lines}") # 注意输出，他每一行算是一个元素， 还有换行符'\n'
# 接下里是readline方法 使用一次，仅去一行函数
line1 = f2.readline()
print(line1)
# 下面是for循环读取文档
# for line2 in f:
# print(line2)
# 每一个line临时变量，就记录了文件的一行数据
# 关闭文件操作： .close()
f.close()
# with open语法
with open("D:\pythonProject12\测试.txt.txt", "r", encoding="UTF-8") as f3:
f3.readlines()
# 执行完该语句块自动关闭文件