python常用数据类型及操作
本文简单记录了python常用的数据类型,主要包括:
- 数值、布尔、字符串;
- 列表、集合;
- 字典;
- 元组;
- 时间日历;
- 迭代器访问集合;
以下为正文
一、数值类型
数值类型常用操作有:数学函数、随机函数、三角函数、
其中,数学函数可以为为内建函数和模块函数:
-
内建函数,如
abs(num)
,max(num1,num2,...)
,min()
,round(num,n)
,pow(x,y)
; -
math
模块函数,如ceil(num)
,floor(num)
,sqrt(num)
,log(x,base)
.
随机函数random
常见方法有:
random()
获取一个随机小数;random.choice(seq)
从seq
队列中,随机选择一个数;uniform(x,y)
取[x,y]
内的随机小数;randomint(x,y)
取[x,y]
内的随机整数;randranges(start,stop)
取[start,stop)
内的随机小数;
####字符串类型
字符串,即单个字符所组成的集合,需要注意的几个转义符:
\
在行尾时表示续行符;\'
单引号;\"
双引号;\n
换行;\t
横向制表符;
原始字符串语法: r"这是一句包括符号 \n 的原始字符串"
.
字符串引号可以混合使用,以避免使用转义符,如:print('输出一个"hello"单词')
,控制台输出为:输出一个"hello"单词 。
二、字符串
字符串拼接
-
拼接,3种方式
-
str1 + str2
-
str1str2
-
"xxx%sxxx" %()
其中%s
是占位符,fang%()
中的内容 -
str *3
-
-
切片
切片是指获取一个字符串的某个片段。获取字符:str[index]
,其中index=-1
表示取字符串最后一位字符。获取一段:str[start:stop:step]
,对应默认为str[0:len(str):1]
,step
可以为负数,此时需要stop<start
。表示从右往左取。
代码示例:
# 输出 helloworld 的3种方式
result = "hello" + "world"
print(result)
result="hello" "world"
print(result)
result ="hello%s"%"world"
print(result)
# %s %d 占位符的使用
result="hello%d,%s"%(world,2)
print(result)
# 输出为helloworld,2
# 打印n遍
print("str\t"*10)
# 输出10遍str,中间用table(制表符)分割
字符串函数操作
查找计算
函数 | 描述 | 备注 |
---|---|---|
len(str) | int len(string) ,返回int ,是内建函数,用来统计字符数量 | \n 算一位,汉字算2位。 |
find() | str.find(substr,start=0,end=len(str)) 查找子串开始位置,找到返回index ,否则-1 | 查找子串位置 |
index() | 参数同find() ,获取子串开始位置,找到返回-1 ,没找到则返回error | 获取子串位置 |
count | 计算某字串出现的次数,参数同上。 |
转换
函数 | 描述 | 备注 |
---|---|---|
string.replace(old,new,count) | 参数对应:旧字符(串),新字符(串),替换个数(默认替换全部) | |
string.capitalize() | 将字符串第一个单词的首字母变成大写 | 不需要传参 |
sring.title() | 将字符串每一个单词的首字母变成大写 | 不需传参 |
string.lower() | 将字符串每个字符都变成小写 | 无参 |
string.upper() | 将字符串每个字符都变成大写 | 无参 |
填充压缩
函数 | 描述 | 备注 |
---|---|---|
string.ljust(width,fillchar) | 对应参数:填充后的长度,填充字符。填充字符必须是一个。在尾部填充。 | 只有参数width>len(string) 时,多余位置才需要使用fullchar 字符进行填充。 |
string.rjust(width,fillchar) | 语义同上,但在首部填充。 | |
string.center(width,fillchar) | 语义同上,但在两边填充。 | |
string.lstrip(chars) | 移除字符串左侧指定字符,默认空白符(\n \t " " ) | |
string.rstrip(chars) | 移除字符串右侧指定字符 |
判定
函数 | 描述 | 备注 |
---|---|---|
isalpha(string) | 判断字符串中所有字符是否都是字母。 | string 不能是空串,有转义字符则为false |
isdigit(string) | 判断字符串中是否都由数字组成。 | |
isalnum(string) | 判断字符串是否由字母和数字组成。 | |
isspace(strind) | 判断字符串是否都由空白符组成。 | |
sting.startswith("substr",start,end) | 判断string ,在下标start 到end 内,是否以某个前缀substr 开头。 | |
str1 in str2 或者 str1 not in str2 | 判断str1 是否在(不在)str2 中。 |
三、列表
列表,即有序的,可变的,元素集合。
区别于字符串的一点,看代码:
s="abc"
print(s[0]) # a
s[0]=d #error 不可换
nums=[1,2,3]
print(type(nums) # <class list>
# 区别于C语言中的数组: C中 int num[]=[1,2,3]
nums=[1,2,3]
numbers=[1,2,[4,5,6]] #列表中还可以嵌套列表
列表定义:
- 使用
range(start,end,step)
生成列表,step
默认是1,start
默认是0; - 从一个
list
推导出另一个list
,有映射和解析。
看代码:
nums=range(99)
print(nums)# 0 1 2 ... 98
nums=range(1,99)
print(nums)# 1 2 ... 98
# python3中,列表在使用时才会生成。
# 映射解析
# 传统
nums=[1,2,3]
resList=[]
for num in nums :
resNum=num ** 2
resList.append(resNum) # 追加
# 列表推导
nums=[1,2,3]
resList=[num+1 for num in nums]
print(resList) # 2 3 4
resList=[num**2 for num in nums]
print(resList) # 1 4 9
# 过滤
#传统
nums=range(100]
resList=[]
for num in nums :
if num%2==0:
resList.append(resNum) # 追加
else
continue
#列表推导
nums=[1,2,3,4]
resList=[num+1 for num in nums if num%2==0] # for 循环可以嵌套,如for num in nums for num2 in nums
print(resList) # 3 5
列表常用操作
函数 | 描述 | 备注 |
---|---|---|
list.append(object) | 追加元素在列表末尾 | 无返回值,None |
list.insert(index,object) | 将元素放在index 之前 | 下标从0开始 |
list.extend(iterable) | 向列表末尾追加另外一个可迭代序列(字符串、列表、元组);如 list1.extend(list2) | |
del list[index] | 删除元素list[index] | num=10 del num 可以直接删除元素 |
list.pop(index=-1) | 删除下标为index 的元素并返回值。默认index=-1 ,即默认删除最后一位元素。。 | 返回值是删除的元素 |
list.remove(object) | 移除指定的元素。不返回值。从前往后寻找,相同元素,只删一个。 | 不要在循环中使用该方法。 |
list[index] | 获取单个元素,index=-1 表示获取末尾元素。 | |
idx=list.index(object) | 获取元素索引,从左往右找,返回第一个找到的元素下标。 | |
list.count(object) | 获取指定元素的个数。 | |
pic=list[start: end :step] | 列表切片。快速生成列表数组。 |
列表遍历
for
循环- 根据索引进行遍历
- 通过枚举函数,生成一个新的对象。
- 利用迭代器遍历
# 1
values=["a","b","a","d"]
currentIndex=0;
for v in values:
print(v)#获取值
print(values.index(v,currentIndex))#获取下标
currentIndex+=1
# 3
values=["a","b","a","d"]
# 第一步:根据列表,创建一个枚举对象
enumerate(values)
print(enumerate(values)) # 无元素内容
print(list(enumerate(values))) # a b a d 转为列表后能输出元素
# 方式一
for tupleValue in enumerate(values): #枚举对象可以直接被遍历
print(tupleValue)
#方式二
for tupleValue in enumerate(values): #枚举对象可以直接被遍历
idx,val=tupleValue
print(idx,val)
#方式三
for idx,val in enumerate(values): #枚举对象可以直接被遍历
print(idx,val)
# 三种方式,输出都为 (0,'a') (1,'b') (2,'a') (3,'d')
迭代器遍历
关于迭代器:
- 是记录位置的对象
- 从第一个元素开始,往后通过
next()
函数,进行遍历 - 只能往后,不能往前
- 判定方法:
isinstance(list,collection.Iterator)
,判断依据是能否作用与next()
函数。
import collections
nums=[1,2,3,4,5]
result=isinstance(nums,collections.Iterable) #判断是否是可迭代对象
print(result) # True
it=iter(nums) # 迭代器,适合于遍历较多元素的列表,遍历到之前,可以不存在,遍历到时进行处理。内部自动记录。
for v in it :
print(v)
# 或者
print(next(it))
判定
object in(not in ) list
,返回bool
型。
比较
cmp(object1,object2)
返回-1,0,1。object
可以是list
,str
,int
…类型。
排序
方式一:内建函数sorted(iterable,key=None,reverse=False)
,返回排好序的列表。可以操作列表,字符串。
方式二:列表对象方法,list.sort(key=None,reverse=False)
。只能操作列表。
乱序和反转
乱序:random.shuffle(list)
反转:list.reverse()
,或者res=list[::-1]
#乱序
import random
l=[1,2,3,4,5]
res=random.shuffle(l)
print(res,l)
# res为Null,l为乱序。
# 反转
l.reverse()
#或者使用切片来反转
res=l[::-1]
print(res)
# 5 4 3 2 1
四、元组
元组,即有序的,不可变的,元素集合。区别于列表:列表是可变的。
元组定义:tupl=(object1,object2,)
,元素可以是任意的,而且互相可以是不同类型的。
列表转为元组:tup=tuple(list)
元组也可以嵌套,列表可以嵌套。元组对象不支持修改,增加,删除.
元组操作:
方法 | 描述 | 备注 |
---|---|---|
tuple[index] | 获取单个元素 | index 可以为负值 |
tuple(start:end:step) | 切片,获取多个元素 | step=-1 可以反转元组 |
元素获取: | ||
tuple.count(item) | 统计元组中指定元素的个数 | |
tuple.index(item) | 获取元组中指定元素的索引 | |
len(tuple) | 返回元组中元素个数 | |
max(tuple);min(tuple) | 返回元组中最大(小)元素的值 | |
判定: | ||
object in tuple;object not in tuple | 返回bool 类型 | |
比较: | ||
cmp(tup1,tup2) | 如果比较的是元组,则针对每个元素,从左到右逐一比较。 | |
拼接: | ||
(元素1,元素2……)*int类型数值 | 同字符串乘法 | |
(元素1,元素2……)+(元素3,元素4……) | 结果为:(元素1,元素2……,元素3,元素4,……) | |
拆包: | ||
a,b=(1,2) 则a=1 b=2 |
五、字典
描述一个人的信息,选用的数据类型,看一段示例:
str1="john,18,170"
infors=str1.split(",")#使用,分割str1
print(infors) # ["john","18","170"]
#不如使用列表
l=["john","18","170"]
l[0]
l[1]
l[2]
# 列表 或者 元组
t=("john","18","170")
t(0)
t(1)
t(2)
# 容易混淆
# 字典
person={"name":jhon,"age":18}
print(person,type(person))# {"name":jhon,"age":18} <class 'dict'>
print(person["name"])# john
print(person["age"]) #18
字典,即无序的,可变的,键值对的集合。无序,所以不能使用下标来访问。字典定义有以下方式:
(key:value,key:value,...)
dict.fromkeys(S,v=None)
,静态方法生成字典。
以上两种方法要求:
key
唯一,否则,后值会覆盖掉前值。key
必须是任意不可变类型(数值,布尔,字符串,元组…)。
python
的字典,采用哈希方式实现。
字典定义方式二实列:
d=dict.fromkeys("abc")
print(d) # {'a':None,'b':None,'c':None}
d=dict.fromkeys("abc",666)
print(d)# {'a':666,'b':666,'c':666}
字典常用操作:
方法 | 描述 | 备注 |
---|---|---|
dict["key"]=value | 增 | |
删 | ||
dic.pop(key) | 弹出键值对,并返回对应的值。若不存在,则返回default 值或报错。dic.pop(key,default) 其中default 可省略。 | |
del dict[key] | key 必须存在,否则会报错。 | |
dic.popitem() | 删除按升序排序后的 第一个键值对,并以元组形式返回键值对。如果字典为空,则报错。 | 无参数 |
dic.clear() | 删除字典内所有键值对,返回None 。字典本身还存在,但内容为空,区别于del | 无参数 |
改值(value ) | 只能改值,不能改value | |
dic[key]=newValue | 修改单个键值,若不存在,则增加。 | |
oldDic.update(newDict) | 批量修改键值对。根据新的字典,批量更新旧字典中的键值对,如果旧字典没有对应的key ,则新增。 | |
查 | ||
dic[key] | 不存在,会报错 | |
dic.get(key,default=None) | 获取指定key 对应的值,若不存在,则返回default ,参数default可以省略。若无,也不会增加。 | |
dic.setdefault(key,default=None) | 获取指定key 对应的值,若不存在,则新增。 | |
dic.values() | 获取所有的值 | 无参数 |
dic.keys() | 获取所有的键 | 无参数 |
dic.items() | 获取字典的键值对 | 无参数 |
遍历 | ||
方式一 | 获取所有key ,遍历所有的key ,再获取对应的value | |
方式二 | 获取所有键值对,再遍历(可以使用元组解包) | |
计算 | ||
len(dict) | 键值对个数 | |
判定 | ||
key in dict | ||
key not in dict |
遍历示例:
d={"name":jhon,"age:"18,"add":shanghai}
# 1.
keys=d.keys()
for key in keys:
print(key)
print(d[key])
# 2.
# 推荐使用
kvs=d.items()
for t in kvs:
print(t)
for k,v in kvs: # 元组解包
print(k,v)
六、集合
集合,即无序的,不可随机访问的,不可重复的元素集合,运算有交、并、差、补等逻辑运算。类别有可变集合set
和不可变集合frozenset
。可变集合支持增删查,不可变集合仅支持查。
可变集合的定义:
set={元素1,元素2,...}
set=set(iterable)
,将可迭代对象转化为集合- 集合推导式:
s=set(x for x in range(1,10) if x%2==0)
不可变集合的定义:
s=frozenset(iterable)
,将可迭代对象转化为集合- 集合推导式:
s=frozenset(x for x in range(1,10) if x%2==0)
Note:
- 常见一个空集合时,不能使用
s={}
,会被识别为字典。正确方式为s=set()
- 集合中的元素是不可变类型(即可哈希的)
- 集合中的元素不允许重复。
集合常用操作
方法(函数) | 描述 | 备注 |
---|---|---|
单一集合操作 | ||
set.add(element) | 增 | |
set.remove(element) | 删 | |
set.pop() | 随机删除 | |
set.clear() | 清空元素,集合本身存在。del set 删除结合 | |
for in 遍历,或者迭代器遍历 | 看代码 | |
集合之间的操作 | ||
result=set1.intersection(set2) 或者& | 返回类型与set1 类型同。可变集合和不可变集合之间可以求交集。集合可以与列表、字符串、元组、字典的键 之间求交集。 | 不会修改原集合 |
set1.intersection_update(set2) | 求交集,无返回值,set1 即为结果 | 会修改原集合 |
result=set1.union(set2) 或者 | | 集合并集 | |
s1.update(s2) | 并集,结果修改到s1 ,无返回值。 | |
result=s1.difference(s2) 或者 - | 差集合,s1 即为结果 | |
s1.difference_update(s2) | 差集(s1-s2) ,结果修改到s1 ,无返回值。 | |
判定 | ||
s1.isdisjoin(s2) | s1 和s2 是否 不相交 | |
s1.issuperset(s2) | s1 集合是否完全包含s2 集合 | |
s2.issubset(s1) | s2 集合是否是s1 集合的子集 | |
集合遍历示例:
# 1.
s={1,2,3}
for v in s:
print(v)
# 2.
s={1,2,3}
its=iter(s)
# print(next(its)) 一次访问一个元素
for v in its:
print(v) # 迭代器不可复用
集合之间操作:
# 求交集
s1={1,2,3,4,5}
s2={4,5,6}
result=s1.intersection(s2)
# 或者
result=s1 & s2
print(result,type(result))# {5,6} <class 'set'>
七、时间日历
time
模块
- 提供处理时间和转换表示的功能
- 获取当前时间戳
- 获取时间元组、获取格式化的时间
- 格式化日期字符串为时间戳
- 获取当前
CPU
时间 - 休眠
n
秒
calender
模块
- 打印文本日历
- 获取某月份日历
datetime
模块
- 获取日期时间
- 计算两个日期之间的差值
- 获取两个日期的时间差
- 计算
n
天后的日期
时间戳
即从1970年1月1号0时0分0秒开始,到所给定日期时间的秒数,是一个浮点数。
获取方式:import time
模块,然后time.time()
获取当前时间元组
time.localtime()
格式化时间
时间戳转为格式化时间:time.ctime(second)
,second
是时间戳,默认当前时间戳。
时间元组转为格式化时间:time.asctime()
。
自定义时间格式
自定义时间格式需要使用函数:time.strftime(格式字符串,时间元组)
代码示例:
import time
result=time.time() #获取时间戳
print(result) # 浮点数
result= time.localtime() #获取时间元组
print(result) # time.struct_time(tm_year=,tm_mon= ...)
#时间戳转格式化时间
t=time.time()
result=time.ctime(t)
print(result) # 星期 月份 时间
#时间元组转格式化时间
t= time.localtime()
result=time.asctime(t)
print(result) #同上
# 自定义时间格式
result=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
print(result) # 年-月-日 时:分:秒
获取CPU
时间
看代码:
# 计算某段代码CPU执行时间
start=time.clock()
for i in range(1,1000)
print(i)
end=time.clock()
print(end-start)
# 休眠n秒
while True:
result=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
print(result) # 年-月-日 时:分:秒
time.sleep(1) # 休眠1秒
calender
模块
导入模块:import calender
,打印某月日历:calender.month(2020,9)
。
datetime
模块,包括datatime
类、time
类、 data
类。具体使用依靠类中的方法。
计算n
天后的日期:result=time + datetime.timedelta(day=n)
看代码:
import datetime
print(datetime.datetime.now()) # 年-月-日 时间
print(datetime.datetime.today())# 同上
t=datetime.datetime.now()
print(t.year)
print(t.day)
#计算n天后的日期
t=datetime.datetime.now()
result=t+datetime.timedelta(day=7)
print(result)
# 计算两日期时间差
first=datetime.datetime(2017,9,2,12,00,00)
print(first) # 日期时间
second=datetime.datetime(2020,9,2,12,00,00)
delta=second-first
print(delta)
print(delta.total.seconds()) # 转换为秒
未完,待续……