python学习之语言基础——基础数据结构（列表、元组、字典、集合、字符串、日期和时间）

目录

序列

列表

创建列表

切片访问列表

增加元素

 删除元素

查找元素

列表排序

 其他操作

 列表遍历

列表生成式

元组

元组创建

字典

创建字典

访问字典

添加、修改、删除元素

遍历字典

字典生成式

集合（和数学中的集合概念一样 ）

创建集合

集合基本操作

交并差集

字符串

基本操作

转义字符

ord和chr

字符串常用函数方法

判断类：输出结果为布尔类型

转换类：返回一个在s基础上转换的字符串，s本身不会变

查找类：

 字符串和列表

split()

join()

日期和时间

指令表

time模块

时间戳

获取本地时间

格式化日期

datetime模块

date日期

time时间

datetime日期时间以及timedelta时间间隔

---

序列

数据类型	定义符号	序列类型	元素是否可以重复	是否有序
列表 list	[]	可变序列	元素可以重复	有序
元祖 tuple	()	不可变序列	元素可以重复	有序
字典 dict	{key:value}	可变序列	key不可重复，value可以重复	无序
集合 set	{}	可变序列	元素不可以重复	无序

列表

创建列表

1、列表名=[element 1，element 2，element 3，……，element n]

2、列表名=list（序列），将序列转换为列表

3、二维列表：a=[[element 1，element 2，element 3],[element 1，element 2，element 3]]

切片访问列表

1、列表是有顺序的，访问每个元素要用“下标”访问；

2、下标就是子元素在列表中从左往右第几个，下标从零开始，即第一个元素的下标（索引）为0；

3、下标只能是[-n,n-1]可以分为[0,n-1]表示顺序第几个，[-n,-1]表示倒数第几个。

aaa=["a","b","c","d","e"]
print(type(aaa))                    #<class 'list'>
print("第一个元素：",aaa[0])          #第一个元素： a
print("第二个元素：",aaa[1])          #第二个元素： b
print("获取倒数第一个元素：",aaa[-1])   #获取倒数第一个元素： e
#aaa[start:end:step] 表示从start开始到end结束步长step获取到的元素组成新列表
print(aaa[0:4:2])     #['a', 'c']

切片:列表的部分元素组成的新列表a[start：end：step]

        —start:切片的下标起点(包含起点)，默认为0

        —end:切片的下标终点(不包含终点)，默认为列表长度

        —step:切片的步长，默认为1

        与range用法基本类似，只是range是数字序列，而切片面向的是任意list

增加元素

方法	解释
a.append(x)	在列表的末尾添加单个元素x，内存地址不变
a,appendleft(x)	在列表的最前边添加，其他元素往后移
a.extend(x)	列表a末尾添加x，x为可迭代对象，包括列表、元祖、字符串等，不能是一个数字
a.insert(idx,x)	在列表a下标为idx的位置插入元素x，原来在下标idx以后的元素往右移一位

a=[1,2]
a.append("hello")
print(a)    #[1, 2, 'hello']
a.extend([123,234,345])  
print(a)      # #[1, 2, 'hello', 123, 234, 345]
a.insert(3,"zzz")
print(a)        #[1, 2, 'hello', 'zzz', 123, 234, 345]

 删除元素

方法	解释
del a[idx]	删除列表a中下标为idx的元素，无返回值
del a	删除名字为a的列表，无返回值，a不存在了
a.pop(idx)	删除列表a中下标为idx的元素，并返回该元素
a,pop()	删除列表a中最后一个元素，并返回该元素
a.remove(x)	删除列表a中值为x的第一个元素
a.clear()	清空列表中所有元素

a=[1,2,3,4,3,2,1]
del a[0]
print(a)     #[2, 3, 4, 3, 2, 1]
a.pop(2)
print(a)     #[2, 3, 3, 2, 1]
a.pop()
print(a)     #[2, 3, 3, 2]
a.remove(3)
print(a)     #[2, 3, 2]

查找元素

1、a.count(x) :计算x在a中出现次数，返回出现次数，如果没有返回0。

2、a.index(x,start,stop) :计算x在列表a下标[start,stop)中第一次出现的位置：

        —x必须在区间[start,stop)中存在，否则报错；

        —start和stop如果没有赋值，则默认为真个列表；

        —只赋值start，stop默认为列表长度。

a=['111','222','333','444','111','222']
print(a.count('111'))      #2
print("列表中第一个222：",a.index('222'))    #列表中第一个222： 1
print("下标2后的第一个111",a.index('111',2))  #下标2后的第一个111 4

列表排序

1、a.reverse() :将列表中元素进行翻转，没有返回值；

2、列表对象的sort :a.sort(key=None,reverse=False):

        —在原列表上进行，key表示排序规则，reverse表示排序方式，默认升序，True为降序；

3、内置函数sorted ：sorted(iterable,key=None,reverse=False)

        —会产生新的列表对象，iterable表示排序的对象。

 其他操作

方法	解释
加号 +	连接两个列表
a*x	a是list，x是int，构成一个新列表，内容是a复制x次
a[idx]='xxx'	列表中下标为idx的元素被xxx替换
a.copy()	复制列表a中的所有元素，生成一个新的列表
b=a[:]	利用切片复制列表；一般的b=a这种赋值不等于复制，只是用两个变量名代表同一个列表
sum(a)	求元素和
max(a)	求最大值
min(a)	求最小值

 列表遍历

a=['z','x','c','v']
for i in a:
    print(i)
#结果
z
x
c
v

a=['z','x','c','v']
for i,v in enumerate(a):
    print(i,v)
#结果
0 z
1 x
2 c
3 v

a=[[1,2,3],[4,5,6],[7,8,9]]
for i in a:
    for j in i:
        print(j,end='\t')
    print()  #换行
#结果
1	2	3	
4	5	6	
7	8	9	

列表生成式

可以基于已有列表生成相关的新列表

[expression for member in iterable]

对于可迭代对象iterable的每个元素member，都执行expression构成新的列表

[expression for member in iterable if conditional]

对于可迭代对象iterable的每个元素member，如果满足条件conditional，才执行expression构成新的列表。

a=[i*i for i in range(10)]
print(a)     #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
b=[i for i in range(10) if i%2==0]     
print(b)     #[0, 2, 4, 6, 8]

元组

与列表区别：列表是可变序列，可以修改而元组是不可变的，如果需要修改就转换为列表或构建新元组

元组创建

1、元组名=（element 1，element 2，element 3，……，element n）

2、元组名=tuple（序列），将序列转换为元组

元组生成式（结果是一个生成器对象，要转化为列表或元组才能看到 ）

t=(i for i in range(1,10))
print(t)      #<generator object <genexpr> at 0x00000179A6459580>
t=tuple(t)
print(t)      #(1, 2, 3, 4, 5, 6, 7, 8, 9)

字典

字典类型是根据一个信息查找另一个信息的方式，构成了“键对值”，就是索引用的建和对应的值构成的成对关系。

字典存储一系列的键值对:key：value，等价于数学中的映射，即一个key对应着一个value。

字典中的key和value之间用冒号:分隔，元素之间用逗号,分隔字典的key只能为数字、字符串、元组不可变类型，大多数情况使用字符串作为key，value的类型没有限制。

创建字典

1、Python中用行{}表示字典，可以使用创建一个字典：d={key1:value1,key2:value2,key3:value3,……}

2、内置函数dict：

—d=dict(key1=value1,key2=value2,key3=value3,……)，此时key只能是字符串

—d=dict([[key1,value1],[key2,value2],[key3,value3],……])，可以传入列表或元组，每个元素是一个包含两个元素的列表或元组，此时第一个元素作键，第二个元素作值。

3、映射函数zip：zip(sequencel, sequence2,...)

把多个序列相同下标的元素组装成元组，结果是一个可迭代对象结果可以转换成list，但是首次转换后迭代器就为空了。假设有一个key列表和value列表，可以利用list(zip(key,value))将二者组装好，然后作为dict的初始化。

d={}       #创建空字典
print(d,type(d))         #{} <class 'dict'>
d0={'a':12,'b':23,'c':34}
print(d0)                #{'a': 12, 'b': 23, 'c': 34}
d1=dict(a=123,b=24,c=345)
print(d1)                #{'a': 123, 'b': 24, 'c': 345}

k=['a','b','c']
v1=[1,2,4]
v2=[7,8,9]
zipped=list(zip(k,v1,v2))
print(zipped)          #[('a', 1, 7), ('b', 2, 8), ('c', 4, 9)]
l1=['aa','bb','cc']
l2=[11,22,33]
d3=dict(list(zip(l1,l2)))
print(d3)              #{'aa': 11, 'bb': 22, 'cc': 33}

访问字典

Python的字典通过key来获取value，把key看做下标即可;

d[x]: d为dict、x为d中的一个key，key必须存在否则会报错。

d={'a':12,'b':23,'c':34}
print(d['a'],d['b'],d['c'])        #12 23 34

函数	作用
d.keys()	获取所有的键
d.values()	获取所有的值
d.items()	获取所有的键值对

添加、修改、删除元素

1. 直接用key和value赋值进行添加或修改，用del删除，d.clear()清空

2. 也可以用d.pop(key,default):返回并弹出对应的值，如果key不存在返回默认值；

        d.popitem() :随机从字典中取出一个键值对，结果为元组类型，同时删除该对。

d={}
d['a']=1     #添加
d['s']=2
d['d']=3
d['f']=4
print(d)   #{'a': 1, 's': 2, 'd': 3, 'f': 4}
d['a']=5     #修改
print(d)   #{'a': 5, 's': 2, 'd': 3, 'f': 4}
del d['s']  #删除
print(d)    #{'a': 5, 'd': 3, 'f': 4}
print(d.pop('f'))  #4
print(d)         #{'a': 5, 'd': 3}
print(d.popitem())   #('d', 3)
print(d)      #{'a': 5}

遍历字典

d={'x':1,'y':2,'z':3}
for i in d:
    print(i)
for i in d.keys():
    print(i)
for j in d.values():
    print(j)
for i,j in d.items():
    print(i,j)
#结果
x
y
z

x
y
z

1
2
3

x 1
y 2
z 3

字典生成式

import random   #random产生随机数
d={item:random.randint(a=1,b=100) for item in range(4)}
print(d)        #{0: 13, 1: 5, 2: 10, 3: 5} 结果随机

集合（和数学中的集合概念一样 ）

创建集合

1. {元素1,元素2,元素3...}:把大括号中的所有元素构造成一个集合，如果有重复元素，只保留1个

2. {}:这是空字典，不是空集合

3. set(x):把x转换成集合，x一般为列表、元组等

4. set():空集

集合基本操作

函数	功能
s.add(x)	集合s中加入元素x
s.update(t)	集合s中加入t，t是另一个集合或者元素
s.remove(x)	集合s删除元素x，如果x不存在则报错
s.discard(x)	集合s删除元素x，如果x不存在不会报错
s.pop()	集合s随机删除一个元素
s.clear()	集合s清空
s.isdisjoint(t)	判断集合s和集合t是否不相交
s.issubset(t)	判断集合s是否为集合t的子集
s.issuperset(t)	判断集合s是否为集合t的超集

交并差集

S={1,2,3}
T={2,3,4}
print("交集：",S&T)    #交集： {2, 3}
print("并集：",S|T)    #并集： {1, 2, 3, 4}
print("差集：",S-T)    #差集： {1}
print("对称差集：",S^T) #对称差集： {1, 4}

函数	功能
s.intersection(tl, t2 ... etc)	集合s与t1,t2.…..的交集，t1是必须的，后续参数可选
s.union(tl, t2 ... etc)	集合s与t1,t2.…..的并集，t1是必须的，后续参数可选
s.difference(t)	s-t的差集
s. symmetric_difference(t)	s,t的对称差集

字符串

字符串:一系列字符，用单引号或者双引号括起；Python不支持单字符类型，单个字符也被看作为字符串，许多用法与List一致。

基本操作

1. 访问字符串中的元素：使用方括号+下标（从0 开始）

2. 切片：s[start:end:step]

3. len(s)：求字符串长度

4. +：字符串连接

5. *：重复（复制）字符串

6. in，not in ：存在，不存在

7. str（x）：把x强制转换成字符串

s="Hello World"
print(len(s))   #11
print("下标",s[2])     #下标 l
print(s[-1])    #d
print(s[4:8])   #o Wo
print(s[:5])    #Hello
print(s[6:])    #World
print(s[-5:])   #World
s1="12345"
s2="6789"
print(s1+s2)    #123456789
print(s1*3)     #123451234512345
if s1 in s:
    print(1)
else:
    print(2)      #2

转义字符

转义字符是以反斜杠()开头的特殊字符，用于表示不能直接键入的字符，例如换行符、引号和反斜杠本身

1. \：续航符，在行尾

2. \\：反斜杠

3. \'：单引号

4. \"：双引号

5. \n：换行符

6. \t：横向制表符

ord和chr

print(ord("张"))   #24352
print(ord("a"))   #97
print(ord("&"))   #38
print(chr(123))   #{
print(chr(99))    #c

字符串常用函数方法

判断类：输出结果为布尔类型

函数	描述
s.isalnum()	判断字符串是否都是字母或者数字
s.isalpha()	判断字符串是否都是字母或中文字符
s.digiht()	判断字符串是否只包含数字
s.islower()	判断字符串是否全小写
s.isupper()	判断字符串是否全大写
s.isspace()	判断字符串是否只包含空白
s.istitle()	判断字符串是否标题化

转换类：返回一个在s基础上转换的字符串，s本身不会变

函数	描述
s.title()	"标题化"的字符串
s.lower()	转换成小写
s.upper()	转换成大写
s.swapcase()	字符串中大写转换为小写，小写转换为大写
s.lstrip(chars)	截掉字符串左边的空格或指定字符chars
s.rstrip(chars)	截掉字符串右边的空格或指定字符chars
s.strip(chars)	调用lstrip([chars])和rstrip([chars])
s.replace(old,new,max)	将字符串中的 old 替换成 new,如果 max指定，则替换不超过 max次
s.ljust(width,[, fillchar])	左对齐,并使用空格(或者fllchar)填充至指定长度width的新字符串
s.rjust(width,[, fillchar])	右对齐,并使用空格(或者llchar)填充至指定长度width的新字符串
s.zfill(width)	右对齐,并使用0填充至指定长度width的新字符串
s.center(width,fillchar)	右对齐，使用空格或者fllchar填充

查找类：

函数	描述
count(str,beg=0,end=len(string))	求str在字符串中出现次数如果指定查找范围则在[beg,end)中查找
find(str,beg=0,end=len(string))	判断str是否在字符串中.如果指定查找范围则在[beg,end)中查找返回找到的起始下标，不存在返回-1
rfind(str,beg=0,end=len(string))	从右往左查找
index(str,beg=0,end=len(string))	与find相同，只是如果str不存在，则抛出异常
rindex(str,beg 0,end=len(string))	从右往左查找
startswith(substr,beg=0,end=len(string))	判断是否以substr开头
endswith(suffix,beg=0,end=len(string))	判断是否以suffx结尾

 字符串和列表

由于字符串本身是不可以修改的，转换成list可以进行修改

split()

利用split()方法对字符串进行分割:

s.split(str="", num=string.count(str))

str表示分割符，默认为空字符，包括空格、换行、制表符等

num表示分割次数，如果设置了这个参数，则最多分割成num+1个子字符串。默认为 -1,即分隔所有

s=input().split()     #2 3 4 5 6 7 8 89
print(s,type(s))      #['2', '3', '4', '5', '6', '7', '8', '89'] <class 'list'>
print(max(s))        #89
s1=str(s)
print(s1,type(s1))     #['2', '3', '4', '5', '6', '7', '8', '89'] <class 'str'>
print(max(s1))       #]

join()

‘—’.join(s)可以把序列s中每个元素用—连接起来。引号''内指定连接的符号，()内是要做出改变的序列

s='asdfghjkl'
s1=list(s)
print(s1,type(s1))   #['a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l'] <class 'list'>
print('-'.join(s))   #a-s-d-f-g-h-j-k-l
print('-'.join(s1))  #a-s-d-f-g-h-j-k-l

日期和时间

指令表

指令	含义
%a	本地化的缩写星期中每日的名称
%A	本地化的星期中每日的完整名称
%b	本地化的月缩写名称
%B	本地化的月完整名称
%c	本地化的适当日期和时间表示
%d	十进制数[01,31]表示的月中日
%H	十进制数[00,23]表示的小时(24小时制)
%I	十进制数[01,12]表示的小时(12小时制)
%j	十进制数[001,366]表示的年中日
%m	十进制数[01,12]表示的月
%M	十进制数[00,59]表示的分钟
%p	本地化的AM或PM
%S	十进制数[00，61]表示的秒
%y	十进制数[00,99]表示的没有世纪的年份
%Y	十进制数表示的带世纪的年份

time模块

时间戳

1. time模块使用时需要导入import time，调用函数时 time.对应功能名称

2. time模块可以获取时间戳，常用于计时，可以计算程序运行时间。

3. s=time.time() 返回一个浮点数表示时间戳，time.sleep(x)表示程序睡眠x秒

import time
start_time=time.time()     #获取开始时间
print(start_time,type(start_time))   #1699964866.2034051 <class 'float'>
time.sleep(3)       #延时3秒 
end_time=time.time()      #获取结束时间
print(end_time,type(end_time))     #1699964869.205605 <class 'float'>
#运行时间
print("{:.2f}".format(end_time-start_time))   #3.01

获取本地时间

time.localtime() ：返回本地时间，是一个struct_time对象，struct_time对象之间不可加减

1. localtime.tm_year：当地时间的年

2. localtime.tm_mon：当地时间的月

3. localtime.tm_mday：当地时间的日，每个月的第几天

4. localtime.tm_hour：当地时间的时

5. localtime.tm_min：当地时间的分

6. localtime.tm_sec：当地时间的秒

7. localtime.tm_wday：当地时间的周，用0-6表示周一到周日

8. localtime.tm_yday：当地时间的天，一年的第几天

import time
localtime=time.localtime()   #获取本地时间
print(localtime,type(localtime))    #数据类型<class 'time.struct_time'>
'''
time.struct_time(tm_year=2023, tm_mon=11, tm_mday=14, tm_hour=20, tm_min=35, tm_sec=23, tm_wday=1, tm_yday=318, tm_isdst=0) <class 'time.struct_time'>
'''
print("年",localtime.tm_year,type(localtime.tm_year))  #年 2023 <class 'int'>
print("月",localtime.tm_mon,type(localtime.tm_mon))    #月 11 <class 'int'>
print("日",localtime.tm_mday,type(localtime.tm_mday))  #日 14 <class 'int'>
print("时",localtime.tm_hour,type(localtime.tm_hour))  #时 20 <class 'int'>
print("分",localtime.tm_min,type(localtime.tm_min))    #分 49 <class 'int'>
print("秒",localtime.tm_sec,type(localtime.tm_sec))    #秒 11 <class 'int'>
print("周几",localtime.tm_wday,type(localtime.tm_wday))  #周几 1 <class 'int'> 
#一年的第几天 318 <class 'int'>
print("一年的第几天",localtime.tm_yday,type(localtime.tm_yday))
#夏令时标识 0 <class 'int'>
print("夏令时标识",localtime.tm_isdst,type(localtime.tm_isdst))

格式化日期

time.strftime(format[,t])：把时间t按照format格式转换，返回一个字符串(时间转化为字符串)

time.strftime(string,format)：把字符串按照format格式转换，返回一个时间字符串转化为时间），第一个参数是字符串类型

import time
t1=time.strftime("%Y.%m.%d %H:%M:%S",localtime)       
print(t1,type(t1))    #2023.11.14 20:57:48 <class 'str'>
t2=time.strptime(t1,"%Y.%m.%d %H:%M:%S")       
print(t2,type(t2))

datetime模块

date日期

使用时导入模块import datetime，调用时datetime.date(日期)

1. a.year：获取datetime.date(日期)中的年

2. a.month：获取datetime.date(日期)中的月

3. a.day：获取datetime.date(日期)中的年日

4. a.weekday()：获取datetime.date(日期)中的周几，还是0-6

import datetime
a=datetime.date(2023,10,1)    #传递日期 年月日
b=datetime.date(2023,11,1)
print(a,type(a))         #2023-10-01 <class 'datetime.date'>
print("年",a.year,type(a.year))    #年 2023 <class 'int'>
print("月",a.month,type(a.month))   #月 10 <class 'int'>
print("日",a.day,type(a.day))       #日 1 <class 'int'>
print("周几",a.weekday(),type(a.weekday()))     #周几 6 <class 'int'>  0-6表示周一到周日
c=b-a     #日期与日期不能相加
print("日期差",c,type(c))   #日期差 31 days, 0:00:00 <class 'datetime.timedelta'>
print(b+c,type(b+c))    #2023-12-02 <class 'datetime.date'>

time时间

调用方法与日期一样

import datetime
a=datetime.time(17,20,00)   #传递时间 时分秒
print('时',a.hour,type(a.hour))    #时 17 <class 'int'>
print('分',a.minute,type(a.minute))    #分 20 <class 'int'>
print('秒',a.second,type(a.second))    #秒 0 <class 'int'>

datetime日期时间以及timedelta时间间隔

使用时，导入datetime模块，调用时用datetime.datetime()传递时间，datetime.timedelta(时间差)时间差用来加减时间

1. datetime.datetime.combine()：连接日期和时间生成日期时间

2. c.strftime("%Y-%m-%d %H:%M:%S")：将时间c按照格式转化为字符串

3. datetime.datetime.strptime("2023-11-11 05:20:00","%Y-%m-%d %H:%M:%S")：将前边的字符串按照后边的格式转化为datetime.datetime

4. datetime.timedelta(days=10) ：获取时间间隔，可以是任何的年月日之类的，这里是10天

5. a_c.seconds：将时间间隔用秒计数

6. datetime.date.today()：获取当天日期

7. datetime.datetime.now()：获取现在的日期时间

import datetime
a=datetime.datetime(2023,11,11,17,20,00)   #传递日期时间  年月日时分秒
b=datetime.date(2023,10,1)
d=datetime.time(5,20,00)
#获取日期、时间
print(a,type(a))     #2023-11-11 17:20:00 <class 'datetime.datetime'>
print(a.date(),type(a.date()))    #2023-11-11 <class 'datetime.date'>
print(a.time(),type(a.time()))    #17:20:00 <class 'datetime.time'>
#日期时间与字符串转化
c=datetime.datetime.combine(b,d)     #连接日期时间
print(c,type(c))      #2023-10-01 05:20:00 <class 'datetime.datetime'>
print(c.strftime("%Y-%m-%d %H:%M:%S"))     #2023-10-01 05:20:00 数据类型为字符串
cc=datetime.datetime.strptime("2023-11-11 05:20:00","%Y-%m-%d %H:%M:%S")
print(cc,type(cc))     #2023-11-11 05:20:00 <class 'datetime.datetime'>
print()
#timedelta时间间隔
print(c>a)     #False
print(a-c,type(a-c))    #41 days, 12:00:00 <class 'datetime.timedelta'>
delta=datetime.timedelta(days=10)     #时间差
print(a+delta,type(a+delta))     #2023-11-21 17:20:00 <class 'datetime.datetime'>
#年月日时分秒转换
a_c=a-c
print(a_c,type(a_c))     #41 days, 12:00:00 <class 'datetime.timedelta'>
print(a_c.days,type(a_c.days))     #41 <class 'int'>
print(a_c.seconds,type(a_c.seconds))       #43200 <class 'int'>
print(a_c.total_seconds(),type(a_c.total_seconds())) #3585600.0 <class 'float'>  统一转换成秒
#获取当前时间
print(datetime.date.today())    #2023-11-14   当前日期
print(datetime.datetime.now())   #2023-11-14 22:32:12.169237   当前日期时间

以上为本人学习笔记，欢迎大家提出建议！