python常用数据类型

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"单词 。

二、字符串

字符串拼接

1. 拼接，3种方式

   • str1 + str2

   • str1str2

   • "xxx%sxxx" %() 其中%s是占位符，fang%()中的内容

   • str *3

2. 切片

切片是指获取一个字符串的某个片段。获取字符：str[index]，其中index=-1表示取字符串最后一位字符。获取一段：str[start:stop:step]，对应默认为str[0:len(str):1]，step可以为负数，此时需要stop。表示从右往左取。

代码示例：

# 输出 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) # 
      
# 区别于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]	列表切片。快速生成列表数组。

列表遍历

1. for循环
2. 根据索引进行遍历
3. 通过枚举函数，生成一个新的对象。
4. 利用迭代器遍历

# 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}  
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} 

七、时间日历

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()) # 转换为秒

未完，待续……