基础数据类型

Python基础数据类型

1.Python中的基本数据类型：

　                数值型(int) 、字符串型(str)、布尔值型(bool)、列表(list)、元组(tuple)、字典(dict)、集合(set)。

2.数值型（int）：

            （ 00101010）₂ = 0*2⁰  + 1*2¹  + 0*2²  + 1*2³  + 0*2⁴  + 1*2⁵  + 0*2⁶  + 0*2⁷   =（42）₁₀

num = 10
print(num.bit_length())          # 当十进制用二进制表示时，最少使用的位数    bit_length()就是帮助你快速的计算整数在#内存中占用的二进制码的长度。

# 运行结果: 4

3.字符串型(str)：

            字符串：Python中凡是用引号引起来的数据可以称为字符串类型，组成字符串的每个元素称之为字符，将这些字符一个一个连接起来，然后在用引号起来就是字符串。

           1、字符串的索引与切片。       

a = "ABCDEFGHIJK"

print(a[0:3])            #输出ABC

print(a[2:5])            #输出CDE

print(a[:])

#输出ABCDEFGHIJK

print(a[:-1])

#输出ABCDEFGHIJ

print(a[-1:-5:-1])

#输出KJIH

print(a[-1:-5:-2])

#输出KI

 

 

startswith 判断是否以...开头

endswith 判断是否以...结尾

a4 = "dkfjdkfasf54"

print(a4[1])    #k

ret4 = a4.endswith("jdk",3,7)
print(ret4) 
     #False
ret5 = a4.startswith("kfj",1,4)
print(ret5)            #True

 

split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。

ret9 = 'title,Tilte,atre,'.split('t')
print(ret9)

#结果    ['', 'i', 'le,Til', 'e,a', 're,']

#rsplit  r表示反向切除，数值表示切除个数
ret91 = 'title,Tilte,atre,'.rsplit('t',1)
print(ret91)

#结果   ['title,Tilte,a', 're,']

format的三种玩法 格式化输出

# format格式化占位符的用法
# 方法一
str1 = "{}{}{}".format("你","好","嘛")
print(str1)       #结果：    你好嘛
# 方法2
str2 = "{1}{0}{1}".format("你","好","嘛")
print(str2)        #结果：    好你好

# 方法三
str3 = "{k1}{k2}{k1}".format(k1="你",k2="好",k3="嘛")
print(str3)        #结果：      你好你

strip　剥夺　

name='*barry**'
print(name.strip('*'))        #结果： barry


print(name.lstrip('*'))       #结果：  barry**
print(name.rstrip('*'))       #结果：  *barry

replace  取代，代替　　

　

str_a = "my name is fu yan lin,my"

print(str_a.replace("my","your",1))

#结果 ：   your name is fu yan lin,my

is系列

name='taibai123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdecimal())  #字符串只由十进制组成

　

字符串首字母变大写　

msg='taibai say hi'
print(msg.title()) #每个单词的首字母大写

#结果：   Taibai Say Hi

print(msg.capitalize()) #首字母大写

   print(msg.swapcase()) #大小写翻转

4.布尔型（bool）：

布尔值就两种：True，False。就是反应条件的正确与否。         真   1   True。            假   0   False。  

 

int   str   bool 三者数据类型之间的转换：

# int ---> bool
i = 100
print(bool(i))  # True  # 非零即True
i1 = 0
print(bool(i1))  # False 零即False

# bool ---> int
t = True
print(int(t))  # 1  True --> 1
t = False
print(int(t))  # 0  False --> 0

# int ---> str
i1 = 100
print(str(i1))  # '100'  

# str ---> int  # 全部由数字组成的字符串才可以转化成数字
s1 = '90'
print(int(s1))  # 90

# str ---> bool
s1 = '太白'
s2 = ''
print(bool(s1))  # True 非空即True
print(bool(s2))  # False
# bool ---> str
t1 = True
print(str(True))  # 'True'

　　　

5.列表(list)：

       1，字符串只能存储少量的数据，对于大量的数据用字符串操作不方便也不易存储。2，字符串存储的数据类型太单一，只能是字符串类型。

            列表是有序的，有索引值，可切片，方便取值。

列表的创建：

# 方式一：（常用）
L = [1, 2, '太白']


# 方式二：（不常用）
L = list()  # 空列表
# L = list(iterable)  # 可迭代对象
L = list('123')
print(L)  # ['1', '2', '3']

# 方式三：列表推导式（后面的课程会讲到）
L = [i for i in range(1,5)]
print(L)  # [1, 2, 3, 4]

　

列表的索引切片：

L = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s"]

print(L[3])          #输出结果： d

print(L[-1])         #输出结果： s

print(L[4:7])        #输出结果： ['e', 'f', 'g']

print(L[:-1])       #输出结果：  ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r']

print(L[::2])       #输出结果：  ['a', 'c', 'e', 'g', 'i', 'k', 'm', 'o', 'q', 's']

print(L[::-1])      #输出结果： ['s', 'r', 'q', 'p', 'o', 'n', 'm', 'l', 'k', 'j', 'i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']

print(len(L))      #输出结果：19     len（）表示长度

列表的增、删、改、查

L = ["1","2","a"]
# 增
L.append("888")    #在L列表的后边追加
print(L)           # 结果：  ['1', '2', 'a', '888']
L.insert(0,"hou")  #在L列表的人日位置追加，0表示索引
print(L)            #结果 ： ['hou', '1', '2', 'a', '888']

L.extend(["how","much","1"])    #迭代着追加，在列表的最后面迭代着追加一组数据，可重复。

print(L)          # 结果： ['hou', '1', '2', 'a', '888', 'how', 'much', '1']


#删


# pop  通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素
l = ['太白', 'alex', 'WuSir', '女神']
ret = l.pop(1)
print(ret,l)                # alex ['太白', 'WuSir', '女神']

# remove  通过元素删除列表中该元素
l = ['太白', 'alex', 'WuSir', '女神']
l.remove('alex')
print(l)                    # ['太白', 'WuSir', '女神']

# clear 清空列表
l = ['太白', 'alex', 'WuSir', '女神']
l.clear()
print(l)                    # []  

# del
#按照索引删除该元素
l = ['太白', 'alex', 'WuSir', '女神']
del l[2]
print(l)                 # ['太白', 'alex', '女神']

# 切片删除该元素
l = ['太白', 'alex', 'WuSir', '女神']
del l[1:]
print(l)                  # ['太白']

# 切片(步长)删除该元素
l = ['太白', 'alex', 'WuSir', '女神']
del l[::2]
print(l)                 # ['alex', '女神']

#改

# 按照索引改值

l = ['太白', 'alex', 'WuSir', '女神']

l[0] = '男神'

print(l) # ['男神', 'alex', 'WuSir', '女神']

 

# 按照切片改值(迭代着增加)

l = ['太白', 'alex', 'WuSir', '女神']

l[1:3] = 'abcdefg'

print(l) # ['太白', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '女神']

 

# 按照切片(步长)改值(必须一一对应)

l = ['太白', 'alex', 'WuSir', '女神']

l[::2] = '对应'

print(l) # ['对', 'alex', '应', '女神']

 

#查

 

#可切片查，可遍历循环查

列表的其它操作

a = ["q","w","q","r","t","y"]

print(a.count("q"))     # 2

print(a.index("q"))      #默认返回第一个的索引值

num = [9,8,6,7,5,4,3,2,1,0]
num.sort()                      #只支持数值型
# 他没有返回值，所以只能打印a
print(num)
num.reverse()
# 他也没有返回值，所以只能打印a
print(num)


import copy                  #引入copy属性
a = [1,2,3,[4,5,6]]
# 浅拷贝
b = copy.copy(a)
print(a)
print(b)

b.append(7）

#深拷贝

b = copy.deepcopy(a)

print(a,b)

列表的相加与相乘：　

l1 = [1, 2, 3]
l2 = [4, 5, 6]
# print(l1+l2)  # [1, 2, 3, 4, 5, 6]
print(l1*3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]　　

6.元祖 （tuple）：

元组:俗称不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改.

 元祖的切片：

tu1 = ('a', 'b', '太白', 3, 666)
print(tu1[0])  # 'a'
print(tu1[-1])  # 666
print(tu1[1:3])  # ('b', '太白')
print(tu1[:-1])  # ('a', 'b', '太白', 3)
print(tu1[::2])  # ('a', '太白', 666)
print(tu1[::-1])  # (666, 3, '太白', 'b', 'a')

　　

元组其他操作方法：

# 可以利用for循环查询元祖

tu1 = ('a', 'b', '太白', 3, 666)
for i in tu1:
    print(i)

#index：通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错。
 
tu = ('太白', [1, 2, 3, ], 'WuSir', '女神')
print(tu.index('太白'))                # 0

#count: 获取某元素在列表中出现的次数
 
tu = ('太白', '太白', 'WuSir', '吴超')
print(tu.count('太白')) # 2

#len

tu1 = (1,2,3,4,84,5,2,8,2,11,88,2)
print(len(tu1))    # 结果:12　

　　

7.字典型（dict）：   

可变与不可变的数据类型的分类：

  

    不可变（可哈希）的数据类型：int，str，bool，tuple。

    可变（不可哈希）的数据类型：list，dict，set。

创建字典型的几种方式：

       

#方式一：
dic = dict((('one', 1),('two', 2),('three', 3)))

#方式二：
dic = dict([('one', 1),('two', 2),('three', 3)])
print(dic)             # {'one': 1, 'two': 2, 'three': 3}

# 方式3:
dic = dict(one=1,two=2,three=3)
print(dic)  # {'one': 1, 'two': 2, 'three': 3}

# 方式4:
dic = dict({'one': 1, 'two': 2, 'three': 3})
print(dic)  # {'one': 1, 'two': 2, 'three': 3}

# 方式5: 
dic = dict(zip(['one', 'two', 'three'],[1, 2, 3]))
print(dic)

# 方式6: 字典推导式 
dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
print(dic)

# 方式7:利用fromkey
dic = dict.fromkeys('abcd','太白')
print(dic)  # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}　　

不合法的字典（key是不可变的）

# dic = {[1, 2, 3]: '周杰伦'}          # list是可变的. 不能作为key

# dic = {{1: 2}: "哈哈哈"}             # dict是可变的. 不能作为key

dic = {{1, 2, 3}: '呵呵呵'}              # set是可变的, 不能作为key

 

字典型的增、删、改、查：

 

#增
 
 
# 通过键值对直接增加
dic = {'name': '太白', 'age': 18}
dic['weight'] = 75               # 没有weight这个键，就增加键值对
print(dic)                       # {'name': '太白', 'age': 18, 'weight': 75}
dic['name'] = 'barry'            # 有name这个键，就成了字典的改值
print(dic)                       # {'name': 'barry', 'age': 18, 'weight': 75}

# setdefault
dic = {'name': '太白', 'age': 18}
dic.setdefault('height',175)                            # 没有height此键，则添加
print(dic) # {'name': '太白', 'age': 18, 'height': 175}
dic.setdefault('name','barry')                          # 有此键则不变
print(dic) # {'name': '太白', 'age': 18, 'height': 175}
#它有返回值
dic = {'name': '太白', 'age': 18}
ret = dic.setdefault('name')
print(ret)                                             # 太白
 
#删
 
 
# pop 通过key删除字典的键值对，有返回值，可设置返回值。
dic = {'name': '太白', 'age': 18}
# ret = dic.pop('name')
# print(ret,dic) # 太白 {'age': 18}
ret1 = dic.pop('n',None)
print(ret1,dic) # None {'name': '太白', 'age': 18}

#clear 清空字典
dic = {'name': '太白', 'age': 18}
dic.clear()
print(dic) # {}

# del
# 通过键删除键值对
dic = {'name': '太白', 'age': 18}
del dic['name']
print(dic)                   # {'age': 18}
#删除整个字典
del dic
 
#改
 
 
# 通过键值对直接改
dic = {'name': '太白', 'age': 18}
dic['name'] = 'barry'
print(dic) # {'name': 'barry', 'age': 18}

# update
dic = {'name': '太白', 'age': 18}
dic.update(sex='男', height=175)
print(dic) # {'name': '太白', 'age': 18, 'sex': '男', 'height': 175}

dic = {'name': '太白', 'age': 18}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(dic) # {'name': '太白', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}

dic1 = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', 'weight': 75} 
 
#查
 
 
# 通过键查询
# 直接dic[key](没有此键会报错)
dic = {'name': '太白', 'age': 18}
print(dic['name']) # 太白

# get
dic = {'name': '太白', 'age': 18}
v = dic.get('name')
print(v)                             # '太白'
v = dic.get('name1')
print(v)                             # None
v = dic.get('name2','没有此键')
print(v)                             # 没有此键 

　　

   keys（）          values（）      items（）    

#keys()
dic = {'name': '太白', 'age': 18}
print(dic.keys()) # dict_keys(['name', 'age']) 

#values()
dic = {'name': '太白', 'age': 18}
print(dic.values()) # dict_values(['太白', 18])

#items()
dic = {'name': '太白', 'age': 18}
print(dic.items()) # dict_items([('name', '太白'), ('age', 18)])

　　

　fromkeys的用法：　

dic = dict.fromkeys('abcd','太白')
print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}

dic = dict.fromkeys([1, 2, 3],'太白')
print(dic) # {1: '太白', 2: '太白', 3: '太白'}