【python的基本数据类型】

由于数据量和数据处理逻辑的难度增加，单纯的excel 处理已经满足不了数据分析师。python 帮助数据分析师做更复杂的处理，以下是我学习过程中觉得比较常见的案例和关键信息点，希望可以帮助初学者学习python 几种数据类型。希望对你有帮助~~~

数值

数字int：pyhthon3的整型都是int 类型，但是python2 的整型分为int 和 long

字符串

字符串str（引号）：双引号"、单引号’、三个双引号"“”、三个单引号’‘’。字符串可以做字符串之间的加法，也可以做字符串*数字等于N倍字符串。ctrl可以看函数 源码。字符串一旦创建不可修改，一旦修改或者拼接则会重新在内存里面创建一个新的字符串并占据新的位置
1）str.casefold()：将大写改为小写，不止包括英文
2）str.lower()：将大写改为小写，只有英文
3）str.upper()：将小写改为大写，只有英文
4）str.center(width，fillchar=None)：width 表示设置宽度，并将内容居中；fillchar默认用空格填空，但可以用其它单个字符替代补充内容。str.ljust(width，fillchar=None)、str.rjust(width，fillchar=None)：将内容居左或者右。str.expandtabs(int)指的是遇到换行符 ，补充空格满int数
5）str.count()：计算字符串出现的次数
6）str.endswith(str)：表示以什么结尾，结果是布尔类型。str.startwith(str)表示以什么开始
7）str.find(str)：找到特定字符串第一个位置，可以限定从第几个位置开始找；str.index 也是找索引位置，但是找不到会报错，但是find 会返回-1
8）str.isalnum(str,num,num)：如果字符串都是字母和数字，返回true ，否则false；islapha是只有英文或者汉字；isdecimal 、isdigit、isnumeric是否是数字，判别能力最强是isnumeric，isdecimal只能识别阿拉伯数字
9）str.isspace()：判断是否全是空格。
10）str.istitle()：判断是否标题样式，标题的话每一个字符串首字母大写 。str.title()，将其转化为标题样式
11) str.lstrip()、str.rstrip()、str.strip()：左、右、所有 空格或者换行去掉。默认是空格，但是也可以去掉值定字符串
12)len()、join：不止字符串，其它类型也可以
13）str.replace(要替换的str，替换成的str，替换的数量)

下面是几种案例：

# format 和 format_map 应用
test='i am {name},{age}' 
print(test) # i am {name},{age}
v=test.format(name='nanna',age=18)
print(v) # i am nana,18
v=test.format(**{"name":'nana',"age":18})
print(v) # i am nana,18
v5='i am {0},{1}'.fomat('nana',18) # 按照索引取值
v6='i am {0[0]},age {1[1]}'.fomat([1,2,3],[11,22,33]) # i am 1,age 11
v2=test.format_map({"name":'nana',"age":18})
print(v2) # i am nana,18

v3='i am %s,%d' %('nana',18)
print(v3) # i am nana,18.%。2f指保留两位小数点的浮点数，需要打印%则用%%
v4='i am %(name)s,%(age)d' %{'name':'nana','age':18}

# expandtabs 应用
nan="uff2r0\thdh\t"
na=nan.expandtabs(4)
print(na) # uff2r0  hdh 

# join 在每一个字符增加符号
nana="#".join(nan)
print(nana) #u#f#f#2#r#0#t#h#d#h

#切片
n1=nan[0:2]
n2=nan=[2]
print(n1,n2) # uff f

列表

列表list：用中括号表示，逗号分割每个元素，元素可以是任何类型，比如数字、字符串、列表、字典等。列表中的元素可以修改，存储的方式是链表，即每一个元素会同时存储下一个元素的位置。列表的元素 是有序的

nana = [2, 3, 5, ["q", "e", "r", "y"], "jinye","2345"]
# 1）修改某个元素
nana[2] = "cute"
nana[4:6] = ["yes", "no"]
nana[1] = [2, 4]
print(nana)  # [2, [2, 4], 'cute', ['q', 'e', 'r', 'y'], 'yes', 'no']

# 2）通过索引或者切片删除某个元素
del nana[2]
print(nana)  #  [2, [2, 4], ['q', 'e', 'r', 'y'], 'yes', 'no'] 
# 删除指定索引(默认最后一个)的元素,并获取到删除值
vli=nana.pop(2)
print(nana)  #  [2, [2, 4], 'yes', 'no']
print(vli) #  ['q', 'e', 'r', 'y']
#通过指定元素值删除元素
nana.remove(2)
print(nana) #  [[2, 4], 'yes', 'no']

# 3）纯字符串元素 的列表转化 为字符串
na = ["345", "fjg"]
na_new = "".join(na)
print(na_new)  # 345fjg

# 4）追加 append 和 extend
na.append(["222","999"])  #追加一个元素
print(na) #  ["345", "fjg", ["222","999"]]
na.extend(["222","999"])  #追加一个for 循环的列表
print(na) #  ["345", "fjg", ["222", "999"]， "222", "999"]

# 5） insert 指定位置插入
na.insert(0,"if")
print(na) #  [0,"345", "fjg", ["222", "999"]， "222", "999"]

# 6) reverse 将当前列表进行反转 
nana.reverse() 
print(nana) #  ['no', 'yes', [2, 4]]

元组

元组tuple：一级元素不可被修改，不可增加或者删除（但可以通过extend在 最后元素进行增加），可以通过索引/切片获取元素，可以通过for循环进行 元素获取。可以for循环的列表/元组/字符串之间可以互相转换且可以利用join进行合并。一般情况下 最后元素加一个逗号。

tup=(9,0,[0,1],("qw","ff",),)

字典

字典dict：元素是以键值对的形式呈现 ，key只能用数字、字符串、元组、布尔值来表示，value可以是任何形式的类型。字典的元素是无序的。

# 循环获取字典的元素
info = {
    "k2": "hhhh",
    "k3":[
        11,
        {'kk1':'vv1',
         'kk3':(11,22)}
    ]
}
print(info["k3"][1]['kk3'][0]) # 11

for k,v in info.items():
    print(k,v) 
# k2 hhhh
# k3 [11, {'kk1': 'vv1', 'kk3': (11, 22)}]

#keys(),values(),items()
print(info.keys()) # dict_keys([2, 'k3'])，获取key,可以用于for循环
print(info.values()) # dict_values(['hhhh', [11, {'kk1': 'vv1', 'kk3': (11, 22)}]])
print(info.items()) # dict_items([(2, 'hhhh'), ('k3', [11, {'kk1': 'vv1', 'kk3': (11, 22)}])])

# fromkeys根据序列创建字典，并指定统一的值
lis=dict.fromkeys([1,2,3],["a","b","c"])
print(lis) # {1: ['a', 'b', 'c'], 2: ['a', 'b', 'c'], 3: ['a', 'b', 'c']}

# get 寻找对应的key的值，若找不到返回特定值
lis=info.get("k2",0000) # print 为"hhhh"
lis=info.get("k",0000) # print 为0000

# pop 和 popitem ,pop删除指定key，popitems随机删除，删除后可以输出删除值和剩余值
info.pop("k2","222") #若有k2删除对应键值对

# setdefalut若发现对应key 不做调整，并返回特定值，否则新增一个键值对，并获取新值
v=info.setdefalut("k22","222") # print 返回k22
v=info.setdefalut("k2","222")  # print 返回 k2

# update 更新，找到对应Key更新，否则新增 
info.update("k2"="2222") 

布尔值

布尔值bool：0、None、{}、[] 都是false ，其它都是true

集合

集合：由不同元素（只能是不可变的变量，比如字符串、数字、元组 ）组合，一组无序排列的可hash值，可以作为字典的key

#普通定义方式
s={1,3,4,6,2,3}
print(s) # s={1,3,6,2} 集合元素去重，且元素的顺序随机
# 指定类型定义方式
s1=set('hello')
s2=set(['1','2','1'])
print(s1) # s1={'h','e','l','o'}
print(s2) # s2={'1','2'}

# 1)add 加一个元素，update 加多个元素
n={'1','2'}
n.add(3) # p.update(linux_1)
print(n) # n={'1','2',3}

# 2) 删除 remove、discard、pop(随机删除一个)
n.remove(3) #若是对应删除值集合没有，报错
n.discard('1') #若是对应删除值集合没有，不会报错，可以执行
print(n) # n={'2'}

# 3)关系判定：取交集
python_1=[1,2,3]
linux_1={1,2,4,5}
python_2=set()
#不同类型或者同类型可以用for循环和if语句
for  p_name in python_1:
    if p_name in linux_1:
        python_2.add(p_name)
print(python_2) # python_2={1,2}
# 集合之间用方法实现
p=set(python_1)
s=p.intersection(linux_1) # p.intersection_update(linux_1) 是将结果直接赋值给p
print(s) # {1,2}
print(p&linux_1) # {1,2}

# 3)关系判定：取并集
print(p.union(linux_1)) # {1,2,3,4,5}
print(p|linux_1)  # {1,2,3,4,5}

# 4）关系判断：取差集
print(p-linux_1) # {3}
print(p.difference(linux_1)) # {3}
p.difference_update(linux_1) # 将差值的结果更新到p

# 5) 关系判断：取交叉补给
print(p.symmetric_difference(linux_1)) # {3, 4, 5}
p.symmetric_difference_update(linux_1)  # 将补集的结果更新到p

# 6）集合关系bool判断
print(p.isdisjoint(linux_1)) # 判断是否有交集
print(p.issubset(linux_1)) # p是不是linux_1的子集
print(p.issuperset(linux_1)) # p是不是linux_1的父集