python基础学习Day_05

引言

确实学的有点快，有些函数忘记了，所以今天就花了点时间总结了很多，大部分还是函数为主，供大家参考

一.字符串

1.索引切片 [start:end:step]

step是步长，间隔多少个字符进行切片,如果为负数，则倒着切

start，从哪个字符开始切

end，从哪个字符结束

word = "Python"
print(word[3:5:1])       #ho
print(word[-1:3:-1])     #no
print(word[-4:-7:-1])    #tyP
print(word[-4:-7:2])     #’‘

2.split切片 split(sep,maxsplit)

""参数是切片的标志，从这个标志开始切

maxsplit参数是最多切几次

默认是从左到右切片，rsplit（）是从右往左切片

instr = 'hello my *name *is LiHua'
print(instr.split("*", maxsplit=1))
#['hello my ', 'name *is LiHua']

3.截掉两边的空格 strip（）

默认两边空格都截掉，rstrip()截掉左边，lstrip（）截掉右边

str1 = " Hello World!  "
str1_2 = str1.strip()

# Hello World!    两边空格没有了

4.字符串拼接 join()

可以让元组，集合，列表中的所有元素连接到一起。但是元组和列表拼接顺序和原来一致，集合拼接会乱序

word = ['hello', 'world', '!', 'haohao']      #hello, world, !, haohao
# word =  ('hello','world')					  #hello, world, !, haohao
# word = {'hello','world','!','haohao'}		  #hello, haohao, world, !
new_word = ", ".join(word)
print(new_word)

5.字符串替换 replace（old,new）

replace有两个参数，第一个参数是原字符串需要替换的部分，第二个参数是替换材料

str2 = "Hello Python!"
str2_1 = str2.replace("Python", "World")     # Hello World!
print(str2_1)

6.是否只有字母isalpha() 是否只有数字isdecimal(),isdight(),isnumeric()

# 检测字符串是否只由字母组成
str3 = "asdfg"
print(str3.isalpha())
# 检测字符串是否只有数字组成
str4 = "23455"
print("23455",str4.isdecimal())
str5 = "4354101010"
print("4354101010",str5.isdigit())
str6 = "154一贰叁四"
print("154一贰叁四",str6.isnumeric())

7.所有字母是否大小写isupper(),islower(),是否标题istitle()

# 所有的字母都是小写
str7 = "alsdhkf"
print(str7.islower())
# 所有的字母都是大写
str8 = "LKSDHG"
print(str8.isupper())
# 判断是否是一个标题,每个单词首字母是否大写
str9 = "Where Are You From"
print(str9.istitle())

8.是否以某个单词开头或者结尾startwith(),endwith()

str10 = "Where Are You Are From"
print(str10.startswith("Where"))
# 检查字符串是否以指定单词结尾
print(str10.endswith("From"))

9查找和逆查找 find()和rfind()

str10 = "Where Are You Are From"
# 该字符串中是否有指定单词 返回为索引 正查找
print("是否有指定单词",str10.find("Are"))
# 逆查找
print("aaaaaaaa",str10.rfind("Are"))

10大小写替换 capitalize(),upple()和lower()

str11 = "where Are You From"
print(str11.capitalize()) # 开头字母变为大写
print(str11.upper()) # 全部变为大写
print(str11.lower()) # 全部变为小写

11.左对齐，右对齐，居中 ljust(),rjust()和center()

这几个函数都有两个参数，第一个参数定义这个字符串的长度，第二个参数是用什么字符去填充空格

# 关于文本对齐 左对齐 右对齐 居中对齐
str = "sklj sklfjsdf sd"  # str的长度+填充符号的长度
print(str.ljust(20, "*"))
print(str.rjust(20, "*"))
print(str.center(20,"="))
print(str.center(40,"*"))

二.列表

列表的特性

列表：有序的可变序列，随时添加或者删除一个元素

列表的定义

列表数据存储：可以存储各个类型的数据

列表的新增 4种

append() 追加在列表的末尾

l1 = ["奥特曼", "变形金刚"]
l2 = [ 1, 2, 3, 4, 5, 6, 7, 8, 9]
l2.append("张三")
print(l2)

insert() 根据索引追加

l2.insert(1, "啦啦啦")

.extend()

l2.extend(l1)

列表的删除有4种

1：del l2[] 按照索引值来进行删除的

l1 = ["奥特曼", "变形金刚"]
l2 = [ 1, 2, 3, 4, 5, 6, 7, 8, 9]
del l1[0]
print(l1)

直接删除列表的最后一位 pop()

l1.pop()
print(l1)

remove() 根据元素的值删除的

l1.remove(3)
print(l1)

clear() 清空

l1.clear()
print(l1)

列表的修改

只有一种

l1[2] = "枪"
print(l1)

列表的查找

index 根据元素内容，匹配相关索引值,查找某元素位置

index_name = l1.index("剑")
print(index_name)

count 查找元素出现的总次数

count = l1.count("刀")
print(count)

3、迭代进行元素输出并比较

l1 = ["剑", 1, 2, 3]
for i in l1:
    if i == "剑":
        print(i)

三.集合

1.集合的创建

1、set1 = set()
2、set1 = {1, 2, 3, 4}

集合的特性

1、无序性：集合没有索引

2、唯一性：去重复集合里面不能添加列表

3、集合可以增删改查，所以集合可以改变，但是里面添加的元素不可变

集合增加 add()

把 m 集合当中的元素添加到 s 中

s = {"a", "b", "c"}
m = {"a1", "b1", "c2"}
for i in m:
    s.add(i)
print(s)

集合的更新 updata()

添加单个元素的时候使用add

批量添加元素：更新updata()

s = {"蔡文姬", "可莉", "贪吃蛇", "消消乐"}
# 添加“曜” ，”瑶“ 批量添加到s集合里面中
s.update("曜" , "瑶")       #   {"蔡文姬", "可莉", "贪吃蛇", "消消乐", "曜" , "瑶"}

集合的删除

1、remove() 移除集合连存在的元素,如果元素不存在,则报错

2、discard()移除集合连存在的元素,如果元素不存在也不报错

s = {"蔡文姬", "可莉", "贪吃蛇", "消消乐"}
s.remove("贪吃蛇")       # {"蔡文姬", "可莉", "消消乐"}
s.discard("可莉1")       # {"蔡文姬", "可莉", "消消乐"}  没有不报错

集合交集并集差集对称差集

a = {1,2,3,4,5,6,7,8,9}
b = {1,3,5,7,9}

差集 a对b的差集

print(a - b) # a存在但是b不存在 
#  {2，4，6，8}

a对b的交集

print(a & b)             # {1,3,5,7,9}
print(s1.intersection(s2))   # {1,3,5,7,9}

a和b的并集

print(a | b)           #{1,2,3,4,5,6,7,8,9}

a和b的对称差集并集减去交集

print(a ^ b)     #{2,4,6,8}

a和b的对称差集

print((a-b) | (b-a))    #{2,4,6,8}

四.字典

字典的特点

1、它是以键值对的形式存在 key - value:它可以存储任意类型的元素

2、无序且可变

3、定义字典的时候,{key:value , key:value , ....}

4、字典中的键：任意不可变的数据类型。value可以是任何类型

字典创建格式

1、d1 = {} #一个空字典
2、d2 = dict() #创建一个空字典
3、key 不可以重复，value可以重复

字典的添加 update()

1、字典的添加根据 dic1[key] = dic1[value]

2、直接更新 d3.update({"eye" : "1.5"})

字典删除

d3 = {"name":"Ray" , "age":18 , "sex":["女"]}

1、通过删除键来删除键值对：del d3["eye"]

2、通过自身键来删除该键值对，这个方法具有返回值:返回value的值 ddd = d3.pop("eye")

3、d3.clear() 清空字典

4、del d3 :直接删除该字典

字典修改

d3["height"] = "2.0" , 直接将value赋值给key

字典的查询

print(d3.keys()) # 打印全部的键

print(d3.values()) # 打印里面全部的值

print(d3.items()) # 打印里面所有的键值对

五.元组，列表，集合，字典的区别

四种数据类型的区别

数据类型	是否有序	是否允许修改	是否修改	是否可使用索引获取元素
列表	有序	允许	可修改	可使用数字索引
元组	有序	允许	不可修改	可使用数字索引
集合	无序	不允许	可修改	无索引
字典	无序	不允许	可修改	有指定索引，无默认的数字索引

四种数据类型的使用场景

列表

存储相同类型的数据。

通过迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作。

元组

函数的参数和返回值。

格式化字符串，格式化字符串后面的（）本质上就是一个元祖。

让列表不可以修改，保护数据安全。

集合

有序的列表

使用集合做排行榜等类型的场景

字典

需要多个键值对，可作为某个事务的说明。

将多个字典放在一个列表中，再进行遍历，再循环体内针对每一个字典进行相同的处理。

六.math模块

1. 导入math模块包

import math
a = 3
b = 4

2. 做基本的数学运算

print(a+b)    #7

3. 幂运算 pow(a,b)

a为底数，b为幂数

result1 = math.pow(a,b) # 3的4次方
print(result1)          #81

4. 平方根 sqrt()

result3 = math.sqrt(100)
print(result3)      #10

5. 四舍五入，内置函数 round(a,b)

a为被操作数字，b为保留几位小数

result4 = round(3.1415926,2)# 不需要math调用,保留两位小数
print(result4)        #3.14

6. 取整，向上取整，向下取整

result5 = math.ceil(9.2) # 向上取整
print(result5)
result55 = math.floor(9.2) # 向下取整

7. 去一个数的绝对值

result6 = math.fabs(-2)
print(result6)
print(abs(-2)) # 括号内是什么类型，打印出来的结果也是啥类型

8. 最大最小值。max、min

print(max(1, 2, 3, 4))          #4
print(min(1,2,3,5,6))           #1

9. 常量

print(math.pi)
print(math.e)

10. 三角函数

print(math.log(2))
print(math.exp(2))

11. 正弦函数、余弦函数

angele = math.radians(30)
print(math.sin(angele))
print(math.cos(angele))
print(math.tan(angele))

七.OS模块

1. 当前文件工作的目录 getcwd()

print(os.getcwd()) 
#D:\往事随风\JAVA\pythonProject\pythonProject\day-12

2. 返回指定路径所有的文件，以及文件夹,将文件夹的内容打印出来 lisdir()

print(os.listdir("D:\往事随风\JAVA\pythonProject\pythonProject\day-12"))

3. 创建多级文件夹 makedirs(name,mode,exist_ok)

makedirs : 一次创建多个文件夹
name : 创建目录的路径名称
mode : 是什么文件
exist_ok : 默认False,如果目录存在创建:FileExistsError
True,创建目录已经存在，不抛出异常

os.makedirs("data2/demo",exist_ok=True)

4. 一次创建单个文件夹

os.mkdir("data2/date3")

5. 判断该文件夹是否存在 exist()

if os.path.exists("data2/date4"): # 返回给我们的是True后者False
print("该文件已存在，不需要二次创建")
else:
os.mkdir("data2/date4")
print("创建成功")
# print(os.path.exists("data2/date3"))

6. 删除文件夹 rmdir()

print(os.rmdir("data2/date3"))

7. 同时删除多个文件夹 removedirs()

os.removerdirs("data2/date4")

8. 文件夹重命名,不需要在意是否有子类文件夹 rename()

# 名称{通过文件夹}
os.rename("data1","dataa1")

9. 判断文件夹内是否有文件 -->有返回值 exists()和isfile()

os.path.exists(" ") #返回给我们的是True或者是False结果
os.path.isfile("text.txt") # 返回给我们的是True或者是False结果

八.random模块

1. 导入random包

import random

2. 随机取一个整数

print(random.randint(1, 10))  # 有返回值对象 ， 前后都可以取到

3. 生成随机偶数 randrange(下限，上限，步长)

print(random.randrange(0, 10, 2))

4. 随机生成一个浮点数 , 默认是计算机小数的长度 , 最大取不到1

print(random.random())         # 0-1之间浮点数

5. 随机生成一个浮点数返回小数的尾数

print(random.uniform(1.2, 1.9))  # 浮点数根据计算机长度来做定长 ， 1之后的数字

6. 随机取序列中的某一位数 choice(数组，k，weight)

随机序列中抽取k个值

weight是权重，出现的概率，数字越大，权重越大，出现的几率越高

print(random.choice([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))

l1 = ["一等奖", "二等奖", "三等奖", "空奖"]
print(random.choices(l1, weights=[1, 2, 3, 20]))  
# 出现的概率，数字越大，权重越大，出现的几率越高

7. 从序列中要取数字，要取多少个 sample(序列，k)

l1 = ["一等奖", "二等奖", "三等奖", "空奖"]
print(random.sample(l1, k=1))  # k代表的是，从列表里随机抽取几个元素
random.shuffle(l1)  # 将列表l1里的数据打乱顺序
print(l1)

九.time模块

1. 导入time包

import time

2. 时间戳 , 以秒为单位从1970年1月1号 0:0:0

t = time.time()
print(t)         #1721059028.6651912

3. 当前时间被格式化,大约能看懂的

t2 = time.localtime()
print(t2.tm_year)       #1024
print(t2.tm_mon)        #7

4. 获取当时的时间，格式化为变成能看懂的样式

t3 = time.strftime("%Y-%m-%d %H:%M:%S", t2)
print(t3)             #2024-07-15 23:57:082024-07-15 23:57:08

5. 格式化本地时间

t5 = time.time()
new_t5 = time.localtime(t5)
print(new_t5)
# time.struct_time(tm_year=2024, tm_mon=7, tm_mday=15, tm_hour=23,
# tm_min=57, tm_sec=8, tm_wday=0, tm_yday=197, tm_isdst=0)

6. 把格式化的时间区分为字符串的形式把字符串转化为元组

t6 = time.strptime("2024-05-02 12:25:00","%Y-%m-%d %H:%M:%S")
print(t6)
# time.struct_time(tm_year=2024, tm_mon=5, tm_mday=2, tm_hour=12,
# tm_min=25, tm_sec=0, tm_wday=3, tm_yday=123, tm_isdst=-1)

7. 结构化时间 {元组}

t = time.localtime()
print(t)
# time.struct_time(tm_year=2024, tm_mon=5, tm_mday=2, tm_hour=12, 
# tm_min=25, tm_sec=0, tm_wday=3, tm_yday=123, tm_isdst=-1)
print(time.asctime(t))
# Mon Jul 15 23:57:08 2024

8. 结构化时间戳 {float}

t1 = time.time()
print(t1)
# 1721059028.670625
print(time.ctime(t1))
# Mon Jul 15 23:57:08 2024

结语

今天是python小白，梦想是月入过万，mai起！