python基本数据类型

• str数据类型

　　　　　　字符串是不可变数据类型，具备以下功能　　　　　

#!/usr/bin/env python
# -*- coding:utf-8 -*-

str
#capitalize 改变字符串首字母为大写
str1 = "andy "
str2 = str1.capitalize()
print(str2)


#casefold 改变字符串中的大写字母为小写,可以对其他国家的语言进行转换
str3 = "ANDy"
str4 = str3.casefold()
print(str4)

#lower 改变字符串中所有的大写字母为小写，只能对英文、拼音、汉字
str5 = "ANDy"
str6 = str5.lower()
print(str6)

#center 填充单个字符，使原字符串居中总长度为指定值
str7 = "andy"
str8 = str7.center(20,'*')
print(str8)

#count 统计字符串中指定字符的个数，可以接收三个参数，第一个为要查找的字符，第二个为查询起始位置，第三个为查询结束位置
str9 = "this is a test"
str10 = str9.count('t')
print(str10)

#endswith 字符串是否以指定的字符结尾，返回bool值(True/False),可以指定起始位置索引和结束位置索引(左闭右开)
str11 = "andy"
str12 = str11.endswith('n',1,-2)
print(str12)

#startswith 字符串是否以指定的字符开头，返回bool值(True/False),可以指定起始位置索引和结束位置索引(左闭右开)
str13 = "andy"
str14 = str13.startswith('an')
print(str14)

#expandtabs 将制表符转换为指定数量的空格，保证总字符长度为指定的长度,如果没有指定参数，默认为8个空格长度
str15 = "andy\tme"
str16 = str15.expandtabs(10)
print(str16)

#find 查找子串在字符串中的索引位置，存在则返回，不存在则返回-1，可以指定起始位置索引和结束位置索引(左闭右开)
str17 = "my name is andy"
str19 = str17.find('name')
print(str19)

#index 查找子串在字符串中的索引位置，存在则返回，不存在则报错，可以指定起始位置索引和结束位置索引(左闭右开)
str20 = "vspoti"
str21 = str20.index('vs')
print(str21)

#判断数字用isdecimal
str22 = "二"
str23 = str22.isalnum() #数字  字符②  汉字二
str25 = str22.isdigit() #数字 字符②
str24 = str22.isdecimal() #数字
print(str23)
print(str24)
print(str25)

#isidentifier 判断字符串是否可以作为变量名(字母、数字、下划线不能以数字开头，不能用python内置关键字)
str26 = "andy"
str27 = str26.isidentifier()
print(str27)

#islower 判断字符串是否都是小写，返回布尔值
str28 = "andy"
str29 = str28.islower()
print(str29)

#islower 判断字符串是否都是大写，返回布尔值
str30 = "andy"
str31 = str30.isupper()
print(str31)

#isprintable 判断字符串中是否包含隐藏的制表符换行符，则不能打印，返回布尔值
str32 = "andy\t is me"
str33 = str32.isprintable()
print(str33)

#isspace 判断是否是空格，返回布尔值
str34 = " \n"
str35 = str34.isspace()
print(str35)


#istitle 判断字符串每一个单词的首字母是否为大写，返回布尔值
str36 = "This Is Test"
str37 = str36.istitle()
print(str37)

#join 把字符串用指定的字符连接起来，连接的对象必须是可以迭代的
str38 = "andy"
str39 = "--r".join(str38)
print(str39)

#ljust 把字符串左对齐，并填充单个字符保证字符串的长度为指定的长度
str40 = "andy"
str41 = str40.ljust(10,"*")
print(str41)

#rjust 把字符串右对齐，并填充单个字符保证字符串的长度为指定的长度
str41 = "andy"
str42 = str41.rjust(10,"*")
print(str42)

#strip 把字符串左右两边的空格去掉,lstrip去掉字符串左边的空格，rstrip去掉字符串右边的空格
str42 = " an dy rr "
str43 = str42.rstrip()
print(str43)

#maketrans  把字符串中的字符进行转换，通过对于的字符映射表
str44 = "andy"
mka = str44.maketrans('a','x')
mkb = str44.translate(mka)
print(mkb)


#partition 把字符串按指定的字符分割，保留分割字符并生成一个新的元组
str45 = "this is a test"
str46 = str45.partition('is')
print(str46)

#split 以指定的字符分割字符串，不保留分割字符，生成一个新的列表
str47 = "this is a test"
str48 = str47.split('is')
print(str48)

#replace 将字符串中的制定字符换成新的字符
str49 = "andy"
str50 = str49.replace('a','y')
print(str50)


#swapcase 将字符串中大写转换为小写，小写转换为大写
str51 = "aNDy"
str52 = str51.swapcase()
print(str52)

#splitlines 按照换行回车分割字符串，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
str53 = "this is a test\n this is a dog"
str54 = str53.splitlines()
print(str54)

#%代表占位符
str55 = "我是:%s,年龄:%s,性别:%s" %("张友",19,"男")
print(str55)

#功能主要是格式化输出,以大括号加索引的形式或者直接指定变量的名字如下
str56 = "我是:{0},年龄:{1},性别:{2}"
str57 = str56.format('张友',20,'男')
print(str57)

str58 = "我是:{name},年龄:{age}"
str59 = str58.format(name='张友',age=19)
print(str59)

#format_map 格式化传入的是一个字典
str60 = "我是:{name},年龄:{age},性别:{gender}"
str61 = str60.format_map({'name':'洋洋','age':18,'gender':'女'})
print(str61)

#以下字符串功能需要多关注：
# name = 'andy'
# name.upper()
# name.lower()
# name.split()
# name.find()
# name.strip()
# name.startswith()
# name.format()
# name.replace()
# "alex".join(["aa",'bb'])


#字符串额外功能：
name = "andy"
#索引取值
print(name[0])
#索引切片
print(name[0:3])
#此次0表示第1个字符，3表示第4个字符，2表示步长
print(name[0:3:2])
#取字符串的长度
print(len(name))
# 可以被for循环
for i in name:
    print(i)

•  list列表 　　　　可变类型,具备以下功能

# ##########################list列表 可变类型###########################
list
#append 向列表中追加元素
lista = ["张友","肖洋","泽泽"]
lista.append("宣萱")
print(lista)

#clear 清空列表中元素
lista = ["张友","肖洋","泽泽"]
lista.clear()
print(lista)

#copy 列表浅拷贝
lista = ["张友","肖洋","泽泽"]
listb = lista.copy()
print(listb)

#count 统计列表中元素的数量
lista = ["张友","肖洋","泽泽"]
listc = lista.count("张友")
print(listc)

#extend 批量添加可迭代的对象到列表
lista = ["张友","肖洋","泽泽"]
lista.extend(["宣萱","浩浩"])
print(lista)

#index 查找列表中对象的索引,如果对象不存在则报错
lista = ["张友","肖洋","泽泽"]
listi = lista.index("肖洋")
print(listi)

#insert 在列表中指定的索引位置插入元素
listc = ["andy","tom","hehe"]
listc.insert(2,"haha")
print(listc)

#pop 没有指定索引位置参数的时候默认删除列表的最后一个元素，指定了索引参数位置可以删除列表任意位置的元素，并且可以获取删掉元素的值
listc = ["andy","tom","hehe"]
liste = listc.pop()
print(liste)
print(listc)

#remove 删除列表中指定的元素，只能指定元素名，不能指定索引，也不能获取删除元素的值
listf = ["andy","hello","vspoti"]
listf.remove("andy")
print(listf)

#del 删除列表中元素，指定索引的位置，不能获取元素的值
del listf[-1]
print(listf)

#reverse 反转列表中元素的位置
listg = ["andy","hello","vspoti"]
listg.reverse()
print(listg)

#sort 对列表排序，默认从小到大，参数reverse=True则从大到小排序
listg = [1,3,2,4]
listg.sort(reverse=True)
print(listg)

#列表中其他比较重要
listh = ["zhangyou","zhangsan","lishi"]
#列表索引
print(listh[0])
#列表切片,o表示开始的索引位置,2表示结束索引位置，1表示步长
print(listh[0:2:1])
#列表是可以迭代的对象，可以使用for循环
for i in listh:
    print(i)
#列表的嵌套
lists = [1,2,3,[2,8,9]]
print(lists)

# 知识拓展
#python2.x中存在range()(一次生成所有需要的元素),xrange(需要的时候才生成不会占用大量的内存)
#python3.x中存在range(),可以指定三个参数，相当于python2.x中的xrange()
for i  in range(1,10,2): #范围左闭右开，并且可以指定步长
    print(i)

for i  in range(10,1,-1): #范围左闭右开，并且可以指定步长
    print(i-1)

#enumerate 为列表额外生成一列有序的数字
listu = ["张友","洋洋","哈哈"]
for i,j in enumerate(listu,1):
    print(i,j)

• 元组

　　　　元组是不可变类型　　

#count 统计元组中元素的个数
tuplea = ("zhangyou","andy","yang")
tuplec = tuplea.count("zhangyou")
print(tuplec)

#index 查找元素在元组中的位置，元素不存在则报错
tupled = ("zhangyou","andy","yang")
tuplee = tupled.index("andy")
print(tuplee)

#元组额外扩展
#元组是可迭代的对象，可以使用for对其进行迭代
tuplek = ("zhangyou","andy","yang")
for j in tuplek:
    print(j)

#索引
tuplej = ("zhangyou","andy","yang")
print(tuplej[0])

#切片
tuplel = ("zhangyou","andy","yang")
tuplem = tuplel[0:1]
print(tuplem)

#元组嵌套，元组本身的元素是不能被修改的，但是元素中包含的列表整体不能被修改，但是能够修改列表中的元素的值
tuplen = ("zhangyou","andy","yang",["张友","洋洋"])
# tuplen[0] = "asss" #此处不支持
# print(tuplen)

tuplen[3][0] = "张学友" #此处支持
print(tuplen)

# **********元组最后一定要加逗号，**********
tuplex = ("zhangyou")
tupley = ("zhangyou",)
print(type(tuplex)) #此处为字符串类型
print(type(tupley)) #此处为元组类型

 

•  字典

　　　　字典是可变无序类型

　　　　

#clear 清空字典中的元素
dicta = {"k1":"v1","k2":"v2"}
dicta.clear()
print(dicta)

#copy 字典浅复制
dicta = {"k1":"v1","k2":"v2"}
dictb = dicta.copy()
print(dictb)

#get 根据字典中的键取值，不存在则返回None
dicta = {"k1":"v1","k2":"v2"}
dictq = dicta.get("k3")
print(dictq)

#pop 根据字典中的键删除相应的键值对，并获取对应键的值,如果不存在则返回错误
dicta = {"k1":"v1","k2":"v2"}
k1value = dicta.pop('k1')
print(k1value)
print(dicta)

#setdefault 在字典中根据键取值，如果不存在则输出指定的默认值
dicta = {"k1":"v1","k2":"v2"}
dicth = dicta.setdefault('k2',"v4")
print(dicth)


#keys 获取字典key的值，并返回一个列表
dicta = {"k1":"v1","k2":"v2"}
dictc = dicta.keys()
print(dictc)

#items 以列表的形式列出字典中的键值对
dicta = {"k1":"v1","k2":"v2"}
dictv = dicta.items()
print(dictv)

#popitem 随机删除字典中的键值对，并返回(字典是无序的)
dicta = {"k1":"v1","k2":"v2"}
dicts = dicta.popitem()
print(dicta)
print(dicts)

#update 更新字典中的键值对，存在则更新，不存在则添加
dicta = {"k1":"v1","k2":"v2"}
dicta.update({"k3":"v3"})
print(dicta)

#values 以列表的形式返回字典中的值
dicta = {"k1":"v1","k2":"v2"}
# dictva = dicta.values()
print(dicta.values())
# print(dictva)

#fromkeys 根据提供的第一个参数可迭代对象作为键，第二个参数作为键值
dicto = dicta.fromkeys(["aa","bb"],"sds")
print(dicto)

dicto = dicta.fromkeys(["aa","bb"],[1,])
dicto['aa'].append(22)
print(dicto)

# 字典额外扩展
#dicta = {"k1":"v1","k2":"v2",{"k3":"v3"},["aa"]:["22"]} #字典的键是不可变类型，此处错误，可以使元组，整数，布尔值

•  整数 不可变类型　

#bit_length 10进制整数能用最少的二进制位表示
intt = 10
ints = intt.bit_length()
print(ints)

#to_bytes 十进制整数用16进制表示，byteorder参数是big时左边补0，参数是small时右边补0
intt = 11
ints = intt.to_bytes(10,byteorder="little")
print(ints)

 

• 布尔值 不可变类型　　　

#数字0是false
#空内容是False,空格是True
a = " "
print(bool(a))

•  set 集合是无序无重复的类型

　　　　

#add 向集合中添加元素
seta = {1,2,3,4,5}
seta.add(9)
print(seta)

#clear 清除集合中的元素
setb = {"张三","李四","王五"}
setb.clear()
print(setb)

#copy 集合浅复制
setb = {"张三","李四","王五"}
setc = setb.copy()
print(setc)

#difference 比较集合的元素差异
setc = {1,2,3,4,5}
setd = {3,4,5,6,7}
sete = setc.difference(setd) #c集合有，d集合没有的
setf = setd.difference(setc) #d集合有，c集合没有的
setl = setc.symmetric_difference(setd) #对称差集
print(sete)
print(setf)
print(setl)

#difference_update 移除所有在另一个集合里拥有的元素
seth = {1,2,3,4,5}
seti = {3,4,5,6,7}
# seth.difference_update(seti)
seti.difference_update(seth)
print(seth)

#discard 移除一个集合里的元素,不存在不报错
seth = {1,2,3,4,5}
seth.discard(1)
print(seth)

#intersection 取两个集合的交集
seth = {1,2,3,4,5}
seti = {3,4,5,6,7}
intsec = seth.intersection(seti)
print(intsec)

# #intersection_update
# seth = {1,2,3,4,5} #把两个集合的交集更新到第一集合中
# seti = {3,4,5,6,7}
# seth.intersection_update(seti)
# print(seth)

#remove 移除集合中的元素，不存在则报错
seth = {1,2,3,4,5}
seth.remove(1)
print(seth)

#pop 任意删除集合中一个不确定的元素，可以获取删除的值
seth = {1,2,3,4,5}
setz = seth.pop()
print(seth)
print(setz)

#update 参数必须是可以迭代的对象
seth = {1,2,3,4,5}
seth.update([7,8])
print(seth)

#集合拓展
#集合是可以迭代的
seth = {1,2,3,4,5}
for i in seth:
    print(i)

#集合是可以嵌套的,不能包含可变类型
#seth = {1,2,3,4,5,(1,2,3),[1,2,3,4]} #错误

seth = {1,2,3,4,5,(1,2,3)}
print(seth)