Python 数据类型

一、数字

#整型int
　　作用：年纪，等级，身份证号，qq号等整型数字相关
　　定义：
　　　　age=10 #本质age=int(10)

#浮点型float
　　作用：薪资，身高，体重，体质参数等浮点数相关

    salary=3000.3 #本质salary=float(3000.3)

#二进制，十进制，八进制，十六进制

#长整形（了解）
    在python2中（python3中没有长整形的概念）：　　　　　　
    >>> num=2L
    >>> type(num)
    <type 'long'>

#复数（了解，推荐视频：https://www.bilibili.com/video/av26786159）　　
    >>> x=1-2j
    >>> x.real
    1.0
    >>> x.imag
    -2.0　　

 

二、字符串
replace/find/join/strip/startswith/split/upper/lowerformat
template = "i am {name}, age : {age}"
v = template.format(name="alex",age=19}
v = template.format(**{"name":"alex","age":19})

#strip
name='*egon**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))

#lower,upper
name='egon'
print(name.lower())
print(name.upper())

#startswith,endswith
name='alex_SB'
print(name.endswith('SB'))
print(name.startswith('alex'))

#format的三种玩法
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)

#split
name='root:x:0:0::/root:/bin/bash'
print(name.split(':')) #默认分隔符为空格
name='C:/a/b/c/d.txt' #只想拿到顶级目录
print(name.split('/',1))

name='a|b|c'
print(name.rsplit('|',1)) #从右开始切分

#join
tag=' '
print(tag.join(['egon','say','hello','world'])) #可迭代对象必须都是字符串

#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))

#isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法
age=input('>>: ')
print(age.isdigit())

#find,rfind,index,rindex,count
name='egon say hello'
print(name.find('o',1,3)) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
# print(name.index('e',2,4)) #同上,但是找不到会报错
print(name.count('e',1,3)) #顾头不顾尾,如果不指定范围则查找所有

#center,ljust,rjust,zfill
name='egon'
print(name.center(30,'-'))
print(name.ljust(30,'*'))
print(name.rjust(30,'*'))
print(name.zfill(50)) #用0填充

#expandtabs
name='egon\thello'
print(name)
print(name.expandtabs(1))

#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='egon say hi'
print(msg.title()) #每个单词的首字母大写

#is数字系列
#在python3中
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

#isdigt:bytes,unicode
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False

#isdecimal:uncicode
#bytes类型无isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False

#isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True

#三者不能判断浮点数
num5='4.3'
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())
'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric
'''

#is其他
print('===>')
name='egon123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成

print(name.isidentifier())
print(name.islower())
print(name.isupper())
print(name.isspace())
print(name.istitle())

def capitalize(self) 首字母大写
def casefold(self) 所有变小写，casefold更强，很多未知的也会相应变小写
def center(self, width, fillchar=None)设置宽度，并将内容居中
def count(self, sub, start=None, end=None)去字符串中寻找子序列的出现次数
def encode(self, encoding='utf-8', errors='strict')
def endswith(self, suffix, start=None, end=None)以什么什么结尾
def expandtabs(self, tabsize=8) 断句tabsize的长度
def find(self, sub, start=None, end=None)从开始往后找，找到第一个之后，获取其索引
def format(self, *args, **kwargs)格式化，将一个字符串中的占位符替换为指定的值
def format_map(self, mapping)格式化，传入的值 {"name": 'alex', "a": 19}
def index(self, sub, start=None, end=None)找不到，报错
def isalnum(self)字符串中是否只包含 字母和数字
def isalpha(self)是否是字母，汉字
def isdecimal(self)当前输入是否是数字 2
def isdigit(self)②，2
def isidentifier(self)
def islower(self)
def isnumeric(self)②，2，二
def isprintable(self)
def isspace(self)
def istitle(self)
def isupper(self)
def join(self, iterable)
def ljust(self, width, fillchar=None)
def lower(self)
def lstrip(self, chars=None)
def maketrans(self, *args, **kwargs)
def partition(self, sep)分割为三部分
def replace(self, old, new, count=None)将指定字符串替换为指定字符串
def rfind(self, sub, start=None, end=None)
def rindex(self, sub, start=None, end=None)
def rjust(self, width, fillchar=None)
def rpartition(self, sep)
def rsplit(self, sep=None, maxsplit=-1)
def rstrip(self, chars=None)
def split(self, sep=None, maxsplit=-1)
def splitlines(self, keepends=None)
def startswith(self, prefix, start=None, end=None)
def strip(self, chars=None)
def swapcase(self)
def title(self)
def translate(self, table)
def upper(self)
def zfill(self, width)
 
# m = str.maketrans("aeiou", "12345")
# new_v = v.translate(m)

 

三、列表
append/ extend/ insert
索引、切片、循环

#ps:反向步长
l=[1,2,3,4,5,6]

#正向步长
l[0:3:1] #[1, 2, 3]
#反向步长
l[2::-1] #[3, 2, 1]
#列表翻转
l[::-1] #[6, 5, 4, 3, 2, 1]

"""
列表【有序可变】
　　作用：多个装备，多个爱好，多门课程，多本书籍等
　　定义：
　　　　[]内可以有多个任意类型的值，逗号分隔
"""
# 创建
li = ['a', 'b', 'cc', 4]  # 定义一个列表一般用这种就可以
# li = list(['a','b','cc',4]) # 定义一个列表
 
# #增加
li.append(5)  # #在列表末尾 添加一个元素,li=['a', 'b', 'cc', 4, 5]
li.insert(0, 'g')  # #在列表末尾 添加一个元素,li=['g', 'a', 'b', 'cc', 4]
li.extend(['gg', 'kk'])  # 添加一个列表['gg','kk'], li=['a', 'b', 'cc', 4, 'gg', 'kk']
 
# # 删除
aa = li.pop() #******pop 删除的时候要保障元素存在，不然会报错******，
print(li,aa)  # 从尾部删除一个元素,并返回删除的元素 ['a', 'b', 'cc'] 4
aa = li.pop(2)  # 删除索引为2的元素,并返回删除的元素['a', 'b', 4] cc
 
aa = li.remove('a')  # 从列表中移除，无返回值 'a',['b', 'cc', 4] None
li.clear()  # 清空列表[]
del li[-1]  # 删除最后一个
 
# # 修改
li[0] = 'A'  # ['A', 'b', 'cc', 4]
 
# # 查找
print(li.index('a'))  # 运行结果0
# 获取该元素，在列表中的索引,（如果列表中有多个相同的元素，只会取找到的第一个元素的索引。
# 当然也可获取某段范围的索引print(liist1.index('d',2,5))）
# 找不到会报错
print(li.count('a'))  # 运行结果1  统计列表中有几个a（元素）
 
# # 其他
li.reverse()  # 反转一个列表,li=[4, 'cc', 'b', 'a']
 
for i in li:  # 循环输出列表元素
    print(i)
 
list1 = ["a", "c", "b", "e", "d"]
list1.sort()  # 排序
print(list1)  # ['a', 'b', 'c', 'd', 'e']
# # python3.x系列的数据类型排序，字符串类型和数字类型不能一起进行排序

 

四、元祖
忽略
索引、切片、循环、元素不能被修改

"""
元组【有序不可变】
　　作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读
　　定义：
　　　　与列表类型比，只不过[]换成()
"""
 
t = ('a',)  # 元祖只有一个元素时，需要加逗号, 和字符串区分开
t = ('a', 'b', 'b', 'c')  # 定义一个元组
t = tuple(('a', 'b', 'b', 'c'))
 
print(t.index('b'))  # 索引出元素第一次出现的位置，还可以指定在某一范围里查找，这里默认在整个元组里查找输出1
print(t.count('b'))  # 计算元素出现的次数，这里输出2
print(len(t))  # 输出远组的长度，这里输出4
print(t[1:3])  # 切片 输出('b','b')
for i in t:
    print(i)  # 循环打印出元组数据

 

五、字典
get/ update/ keys/ values/ items
for循环，索引。不可以切片

"""
字典【无序可变】
　　作用：存多个值,key-value存取，取值速度快
　　定义：
　　　　key必须唯一，必须是不可变类型，value可以是任意类型
"""
 
# 创建：
info = {"name": "tom", "age": 18, "gender": "male"}  # 本质info=dict({"name":"tom","age":18})
# info=dict(name='tom',age=18,gender='male')
# info=dict([['name','tom'],('age',18)])
# info={}.fromkeys(('name','age','gender'),None) #{'name': None, 'gender': None, 'age': None}
 
# 增加
info['salary'] = 50000  # {'name': 'tom', 'age': 18, 'salary': 50000, 'gender': 'male'}
 
# 删除
info.pop('age')  # 根据键删除某一元素 d={'Michael': 95, 'Tracy': 85}
info.popitem()  # 随机删除
info.clear()  # {}
 
# 修改
info['age'] = '25'  # 如果没有该key，则在字典创建新的的的key-value
 
# 查询
info.get('age')  # 根据key获取values，如果不存在返回None，这里输出75
'''
setdefault的功能
1：key存在，则不赋值，key不存在则设置默认值
2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值
'''
print(info.setdefault('age', 50000))  # 18
print(info.setdefault('salary', 50000))  # 50000
print(info)  # {'age': 18, 'name': 'tom', 'salary': 50000, 'gender': 'male'}
 
# 其他
print(len(info))  # 输出字典长度
print('age' in info)  # python3 中移除了 has_key,要判断键是否存在用in
 
for i in info:
    print(i)  # 循环默认按键输出
 
for i in info.values():  # 循环按值输出
    print(i)
 
for k, v in info.items():  # 循环按键值输出
    print(k, v)
 
seq = ('Google', 'Runoob', 'Taobao')
seq2 = ('1', '2', '3')
d1 = dict.fromkeys(seq)
d2 = dict.fromkeys(seq,seq2)
 
print(d1) # {'Google': None, 'Taobao': None, 'Runoob': None}
print(d2) # {'Taobao': ('1', '2', '3'), 'Google': ('1', '2', '3'), 'Runoob': ('1', '2', '3')}

def clear(self)
def copy(self)
@staticmethod # known case
def fromkeys(*args, **kwargs)
def get(self, k, d=None)
def items(self)
def keys(self)
def pop(self, k, d=None)
def popitem(self)
def setdefault(self, k, d=None)
def update(self, E=None, **F)
def values(self)

"""
集合【无序可变】
　　作用：去重，关系运算
　　定义：
　　　　 1：每个元素必须是不可变类型(可hash，可作为字典的key)
         2:没有重复的元素
         3：无序
         4：可以包含多个元素，用逗号分割，
"""
a = {1, 2, 3, 4, 5, 6, 7, 8, 9}
b = {1, 3, 9, 10, 11}
 
a.add(10)  # 添加一个元素
 
a.discard(1)  # 删除元素1，不存在的话不报错
a.remove(1)  # 删除元素1，不存在的话报错
a.pop()  # 随机删除
 
a.update([1, 8, 34])  # 更新，没有就添加，有就不添加
 
# 并集
a.union(b)
a | b
# 返回一个新的集合包含a和b的所有元素
 
# 交集
a.intersection(b)
a & b
# 返回一个新的集合包含a和b的公共元素
 
# 差集
a.difference(b)
a - b
# 返回一个新的集合，包含a中的元素，但是没有b中的元素
 
# 对称差集
a.symmetric_difference(b)
print(a ^ b)
# 返回一个新的集合包含 a和b中不重复的元素

 

六、布尔值
bool()强转成布尔值
None / "" / ()/ {}/ []/ 0 ---->  False

七、可变/不可变类型
可变类型：修改变量的值，ID号不变。也就是不可哈希的数据类型
列表，字典,集合
不可变类型：修改变量的值，ID号变化。也就是可哈希的数据类型
字符串，数字，元祖

八、按照访问顺序
顺序访问：字符串，元组，列表
映射关系访问：字典

九、容器
列表，元组，字典
原子：数字，字符串 （只能存放一个元素）
"""

s='abcdefghigk'
print (s[0:3]) #截取第一位到第三位的字符  #abc
print (s[:] )#截取字符串的全部字符 #abcdefghigk
print (s[6:]) #截取第七个字符到结尾 #ghigk
print (s[:-3] )#截取从头开始到倒数第三个字符之前 #abcdefgh
print (s[2]) #截取第三个字符 #c
print (s[-1] )#截取倒数第一个字符 #k
print (s[::-1]) #创造一个与原字符串顺序相反的字符串 #kgihgfedcba
print (s[-3:-1] )#截取倒数第三位与倒数第一位之前的字符 #ig
print (s[-3:]) #截取倒数第三位到结尾 #igk
print (s[0:10:2])#每隔一个，取一个值 #acegi
print (s[0:10:3])#每隔2个，取一个值 #adgg

对于字典、列表等数据结构，深拷贝和浅拷贝有区别，从字面上来说，可以看出深拷贝可以完全拷贝，浅拷贝则没有完全拷贝。

#字典只有顶级对象(源变了，深浅copy没变)
import copy  #导入copy模块
info = {'name':'tom','age':18}  #原始字典
info_copy = copy.copy(info) #浅拷贝
info_deep = copy.deepcopy(info) #深拷贝
print(info)
print(info_copy)
print(info_deep)
id(info);id(info_copy);id(info_deep)  #3个不同的对象,id不一样
info['age'] = 19  #源变了，深浅copy没变
 
#字典嵌套可变对象 （源和浅copy变了，深copy没变）
import copy  #导入copy模块
info = {'name':'tom','age':18,'job':['it','design']}  #原始字典
info_copy = copy.copy(info) #浅拷贝
info_deep = copy.deepcopy(info) #深拷贝
 
id(info);id(info_copy);id(info_deep)  #3个不同的对象,id不一样
info['job'][0] = 'boss'  #源和浅copy变了，深copy没变
print(info)#{'age': 18, 'job': ['boss', 'design'], 'name': 'tom'}
print(info_copy)#{'age': 18, 'job': ['boss', 'design'], 'name': 'tom'}
print(info_deep) #{'age': 18, 'job': ['it', 'design'], 'name': 'tom'}
 
'''
 
深浅copy都是对源对象的复制，占用不同的内存空间。
如果源对象只有一级目录的话，源做任何改动，不影响深浅拷贝对象
如果对象不止一级目录，源做任何改动，都要影响浅拷贝，但不影响深 拷贝

 

# 练习
'''
l = [11,22,33,44,55,66,77,88,99,90]
result = {}

for item in i:
    if item < 66:
        #
        #
        if "k1" not in result:
            result["k1"] = [item, ]  # {"k1":[11,]}
        else:
            result["k1"].append((item))
    elif item > 66:
        if "k2" not in result:
            result["k2"] = [item, ]  # {"k1":[11,]}
        else:
            result["k2"].append(item)
'''

# 练习13 有两个列表
'''
        l1 = [11,22,33]
        l2 = [22,33,44]
    a.获取内容相同的元素列表
    b.获取l1中有，l2中没有的元素列表
    c.获取l2中有，l3中没有的元素列表
    d.获取l1和l2中内容都不同的元素列表

l1 = [11,22,33]
l2 = [22,33,44]
s1 = set(l1)
s2 = set(l2)
s3 = s1.difference(s2)    # s1 中有，S2中没有 {11}
print(s3)
s4 = s2 - s1  # s2中有，s1中没有 {44}
print(s4)
s5 = s1 & s2  # s1 和 s2中相同的元素。 {33, 22}
print(s5)
s5 = s1.symmetric_difference(s2)  # s1 和 s2中不同的元素 {11, 44}
print(s5)
'''

# 练习20 用Python开发程序自动计算方案：
'''
公鸡5文钱一只，母鸡3文钱一只，小鸡3只一文钱，用100文钱买100只鸡，其中公鸡，母鸡，小鸡都必须要有
问公鸡，母鸡，小鸡要买多少只刚好凑足100文钱?

gongji = 5
muji = 3
xiaoji = 1/3

for gongji_num in range(1,101):  #制作一个循环，求出满足条件的解
    for muji_num in range(1,101-gongji_num):
        xiaoji_num = 100-gongji_num-muji_num
        money = gongji * gongji_num + muji * muji_num + xiaoji * xiaoji_num
        if money == 100:
            print("公鸡: %d，母鸡: %d，小鸡: %d" % (gongji_num,muji_num,xiaoji_num))
'''

#练习 有1、2、3、4、5、6、7、8。8个数字能组成多少个互不相同且无重复数字的两位数？
#重复的计算用循环去做是比较适合的。先取一个数，循环8次 把值进行判断，如果不同就加进数字列表
'''
nums = []
for i in range(1,9):
    for v in range(1,9):
        str_num = str(i) + str(v)
        num = int(str_num)
        if num not in nums and i != v:
            nums.append(num)
print(nums)
print(len(nums))
'''
#列表
'''
l = []
print(id(l))
l.append(2)  # 9127376  #5064144
print(l)
print(id(l))
l[0] = 5
print(l)
print(id(l))
'''
#数字
'''
age = 1
print(id(age))  # 1834312800
age = 2
print(id(age))  # 1834312816
'''
#元祖
'''
tu = (1,2,3)
print(id(tu))  # 10180288
'''
#字典
# '''
dict = {"name":"alex"}
print(id(dict))  # 5138304
dict["name"] = "qa"
print(id(dict))  # 5138304

#字符串
'''
name = "alex"
id(name) # 4378016
name = "al"
id(name)  # 4454400
'''

#集合
'''
set = {1,2,3,4}
id(set)
set.add(5)
id(set)
'''

列表
一．新建列表的方式
1.li = [“a”, ”b”, ”c”, 1, 2, [“a1”]]
2.str.split()
来得到列表, 字符串的内置方法
3.通过用list()直接转成列表，iterable可迭代的对象。
str = “hello world, good morning”  ---》li = list(str)
通过range（）来生成列表。list(range(10))
list(dict.keys())
list(dict.values())
list(dict.items())
4.列表生成式： [x * 2 for x in range(10)] X一定是可迭代对象的item.得到是一个列表

二．增。增加元素
li.insert(3,“d”) ---> 索引位，元素。将元素插入到索引位。
li.append(“e”) --- > 在列表中追加一个元素。
li.extend(iterable) - --> 拓展列表，用iterable的对象去拓展

三．删。删除元素
li.clear() - --> 清空列表
li.pop() - --> 默认是删除最后一个，删完了之后会返回删除的值
del (li[2]) - --> 删除列表元素
li, remove(value) - --> 删除列表值，参数是元素

四．改。修改元素的值
li[2] = “value” ---> 覆盖掉原值，就修改了原来的值
li.sort() - --> 排序
li.reverse - --> 反转
sorted(li) - --> 生成副本，对副本进行排序，不影响原列表顺序

五．查。查找元素
li.index(value) - --> 元素的索引
li[0] - --> 已知索引，去取元素
li[:2] - --》 取多个元素
li[::-1] - --》reverse
count(value) - --> 会返回value出现的次数
"""

# 生成字典的方式:
'''
1.person = {"name":"alex","age":10}
2.person = dict(name="alex",age=10)
3.keys = [1,2,3,4,5]
  {}.fromkeys(keys,[])   # {0: [], 1: [], 2: [], 3: [], 4: []}
4.d = {}
  for k,v in iterable:
        d[k] = v 
  
'''
# 增加字典
'''
1.直接给key赋值，如果存在，修改value值，不存在就新增键值对（d = {} ---> d["key"] = value） 
2.使用dict.setdefault(key,value=0)，如果key存在，不修改value值，如果不存在，新增键值对。返回key对应value值。只新增不修改
'''
# 删除
'''
1.dict.pop(k[,d])  # 删除指定key,找到key 就删除键值对，返回value值。 如果找不到key, pop(k,v)给了v值，返回v，没给v,抛出异常
2.dict.popitem()  # 删除任意的键值对
3.dict.clear()  # 清空字典
4.内置函数del() 
'''

# 修改
'''
1.person[key] = value # 没有key的时候新增键值对，已存在的时候，修改值。
2.dict1.update(dict2)  相当于li.extend(li2).用字典2中的k,v去更新字典1.如果不存在，就新增到字典1，如果存在，更新value值
'''

# 查
'''
1.dict[k]  # 返回k 对应的v 值，如果找不到k，报错
2.dict.keys()  # dict_keys(['a', 'b', 'c', 'd'])
3.dict.values()  # dict_values([[], [], [], []])
4.dict.items()  # dict_items([('a', []), ('b', []), ('c', []), ('d', [])])
5.dict.get(k,default=None)  # 返回k对应的v 值，如果找不到，返回default
'''

# 循环
'''
1.for k,v in dict.items()
2.for k in dict.keys()
3,for v in dict.values()
'''