Python基础二——数据类型初识

1、整数int

int主要用于计算-----“i.bit_length()”:表示i所占用的最少二进制位数。

#int-----i.bit_length():表示i所占用的最少二进制位数。
i= 13
print(i.bit_length())

2、布尔值bool

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

真   1   True。

假   0   False。

3、字符串str

string主要用于存放少量的数据，便与后续操作。

整型int和字符串str之间的相互转换：

  int ---> str      str(int)

  str ----> int      int(str)  str此时只能是数字的组合

整型int和布尔值bool之间的相互转换：

  int ----> bool      非0时值为True,为0时值为False

  bool ----> int      True转换为整数int型时值为1，False转换为整数int型时值为0

# int ---> bool      非0时值为True,为0时值为False
a = bool(2)
b = bool(0)
print(a)             #运行结果：True
print(b)             #运行结果：False
#bool ---> int        True转换为整数int型时值为1，False转换为整数int型时值为0
c = int(True)
d = int(False)
print(c)             #运行结果：1
print(d)             #运行结果：0　　

 字符串str和布尔值bool之间的相互转换：

  str ---> bool     非空 返回值是True，空返回值就是False
  bool ---> str     str(True)     str(False)

#str - --> bool    非空返回值是True，空返回值就是False
i = bool('3')
print(i)           #运行结果：True
i = bool(0)
print(i)           #运行结果：False
i = bool('')
print(i)           #运行结果：False
#bool - --> str     str(True)     str(False)
i= str(True)
print(i)           #运行结果：True
i= str(False)
print(i)           #运行结果：False

常见知识点补充：if条件语句和while循环语句中用于条件判断。

if 1:
    print('a')
else:
    print('b')       #运行结果：a
if 0:
    print('a')      
else:
    print('b')       #运行结果：b
while True:
    print('a')
    break            #运行结果：a
while 1:             # 和while True比较while 1 的执行效率高
   print('b')
   break             #运行结果：b

4、字符串的索引与切片　

　索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。

a = "a1b2c3"
print(a[0])           #运行结果：a
print(a[1])           #运行结果：1
print(a[2])           #运行结果：b

切片就是通过索引（起始索引：终止索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。

a = 'ABCDEFGHIJK'
print(a[0:3])                    
print(a[2:5])
print(a[0:])  #默认到最后
print(a[:])  #从头到尾
print(a[0:-1]) #-1就是最后一个
print(a[0:5:2]) #加步长
print(a[5:0:-2]) #反向加步长
print(a[-1:-6:-2])#反向取加步长

　以上代码的输出结果：

ABC
CDE
ABCDEFGHIJK
ABCDEFGHIJK
ABCDEFGHIJ
ACE
FDB
KIG

 字符串常用方法：format与格式化输出类似但是各有不同的应用场景。

#第一种
s = '我叫{},今年{},身高{}'.format('金鑫',21,175)
print(s)
#第二种
s = '我叫{0},今年{1},身高{2},我依然叫{0}'.format('金鑫',21,175)
print(s)
#第三种
s = '我叫{name},今年{age},身高{high}'.format(name = '金鑫',high=175,age=21)
print(s)　

字符串的常用方法

s= "aBc d12%h&j("
print(s.capitalize())     #字符串的首字母大写                       运行结果：Abc d12%h&j(
print(s.swapcase())       #大小写翻转                               运行结果：AbC D12%H&J(
print(s.title())          # 非字母隔开的地方首字母大写，其它小写    运行结果：Abc D12%H&J(
print(s.upper())          #全部大写                                 运行结果：ABC D12%H&J(
print(s.lower())          #大全部小写                               运行结果：abc d12%h&j(
print(s.center(25))       #将内容居中                               运行结果：       aBc d12%h&j(
print(s.center(25,'*'))   #将内容居中两边用*填满                    运行结果：*******aBc d12%h&j(******
print(s.expandtabs())     #字符串中的 tab 符号('	')转为空格，tab 符号('	')默认的空格数是 8
print(s.find('d'))       #通过元素找索引,可以整体找,可以切片,找不到返回-1     运行结果：4
print(s.index('d'))      #通过元素找索引,可以整体找,可以切片,找不到会报错     运行结果：4
print(s.startswith('a')) #检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False
print(s.endswith('('))   #检查字符串是否是以指定子字符串结尾，如果是则返回 True，否则返回 False
print(s.strip())         #去除字符串前后两端的空格,换行符,tab键或指定字符等     运行结果：aBc d12%h&j(
print(s.lstrip())        #截掉字符串左边的空格或指定字符                        运行结果：aBc d12%h&j(
print(s.rstrip())        #截掉字符串右边的空格或指定字符                        运行结果：aBc d12%h&j(
print(s.split('b',3))    #通过指定分隔符对字符串进行切片--->list                运行结果：['aBc d12%h&j(']
print(s.replace('a','小',2)) #用“小”替换字符串里的“a”2次                   运行结果：小Bc d12%h&j(
print(s.isalnum())       #字符串由字母或数字组成                                运行结果：False
print(s.isalpha())       #字符串只由字母组成                                    运行结果：False
print(s.isdigit())       #字符串只由数字组成                                    运行结果：False
print(s.count('a'))      #统计“a”在字符串中出现的次数。                       运行结果：1
print(len(s))            #计算字符串“s”的长度或项目个数                       运行结果：12
#strip应用举例：
name = input('请输入名字:').strip()
if name == 'alex':
    print('somebody')
else:
    print('请重新输入')
#upper和lower应用举例，全部大写和全部小写实际应用：不区分大小写的验证码。
code = 'aeDd'
your_code = input('请输入验证码:')
if your_code.upper() == code.upper():
    print('输入正确')
else:
    print('请重新输入')

 5元祖

元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）

元祖里包含的列表元素，此列表的元素可被修改。

元祖也适用count、len、index等。

#元祖的
#当元组只有一个元素组成并且没有','
# 则该元素是什么数据类型,整体就是什么数据类型.
tu1= ([1,2])
print(type(tu1))  #<class 'list'>
tu2 = ('abc')
print(type(tu2))  #<class 'str'>

6列表

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型。

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

列表的增，共有三种方法：

#第一种：append插在最后
l1 = ['小明','小芳',2,'小花','abc']
l1.append('w')
l1.append([1,2,'qq'])
print(l1)                           #运行结果：['小明', '小芳', 2, '小花', 'abc', 'w', [1, 2, 'qq']]
#第二种：insert按照索引插入
l1 = ['小明','小芳',2,'小花','abc']
l1.insert(1,"you")
print(l1)                           #运行结果：['小明', 'you', '小芳', 2, '小花', 'abc']
#第三种：extend,批量增加在最后
l1 = ['小明','小芳',2,'小花','abc']
l1.extend([1,'g',9])
print(l1)                           #运行结果：['小明', '小芳', 2, '小花', 'abc', 1, 'g', 9]

列表的删，共四种方法：

#第一种：pop,默认删除最后一个，也可按照索引删。
l1 = ['小明','小芳',2,'小花','abc']
l1.pop()
print(l1)                            #运行结果：['小明', '小芳', 2, '小花']
l1 = ['小明','小芳',2,'小花','abc']
ret = l1.pop(2)
#有返回值
print(ret)                           #运行结果：2
print(l1)                            #运行结果：['小明', '小芳', '小花', 'abc']
#第二种:remove,按照指定元素删除
l1 = ['小明','小芳',2,'小花','abc']
l1.remove("小明")
print(l1)                            #运行结果：['小芳', 2, '小花', 'abc']
#第三种：clear，清空列表
l1 = ['小明','小芳',2,'小花','abc']
l1.clear()
print(l1)                            #运行结果：[]
#第四种：
# del:删除列表
l1 = ['小明','小芳',2,'小花','abc']
del l1
#按照索引删除：也可以切片删除
l1 = ['小明','小芳',2,'小花','abc']
del l1[2]
print(l1)                            #运行结果：['小明', '小芳', '小花', 'abc']
l1 = ['小明','小芳',2,'小花','abc']
del l1[0:1]
print(l1)                            #运行结果：['小芳', 2, '小花', 'abc']

列表得改：

l1 = ['小明','小芳',2,'小花','abc']
#按照索引改，
l1[0] = '小马'
print(l1)                            #运行结果：['小马', '小芳', 2, '小花', 'abc']
#按照切片改
l1[0:2] = ['小猫','小狗']
print(l1)                            #运行结果：['小猫', '小狗', 2, '小花', 'abc']

列表的查：

#列表的查
l1 = ['小明','小芳',2,'小花','abc']
#按照索引查
l1[1]                                #运行结果：小芳
print(l1[1])
#按照切片查
l1[0:2]
print(l1[0:2])                       #运行结果：['小明', '小芳']
#for循环来查
for i in l1:
    print(i)　

 其他操作：

count（数）（方法统计某个元素在列表中出现的次数）。

1 a = ["q","w","q","r","t","y"]
2 print(a.count("q"))

index（方法用于从列表中找出某个值第一个匹配项的索引位置）

1 a = ["q","w","r","t","y"]
2 print(a.index("r"))

len（计算列表的长度）

#len计算列表的长度
l1 = ['小明','小芳',2,'小花','abc']
len(l1)
print(len(l1))                      #运行结果：5

 sort （方法用于在原位置对列表进行排序）

 reverse （方法将列表中的元素反向存放）

# sort从小到大排序
l1 = [1,4,6,3,8,7]
l1.sort()
print(l1)                           #运行结果：[1, 3, 4, 6, 7, 8]
#将列表反向排序
l1 = [1,4,6,3,8,7]
l1.reverse()
print(l1)                           #运行结果：[7, 8, 3, 6, 4, 1]
#将列表反向按照从大到小排序
l1 = [1,4,6,3,8,7]
l1.sort(reverse = True)
print(l1)                           #运行结果：[8, 7, 6, 4, 3, 1]

 range的用法：指定范围，生成指定数字。

#range当做:范围列表[],列表中的元素是数字,且可控的有效数字范围
#一般与for 配合使用
for i in range(1,5):
    print(i)             #运行结果：1234
for i in range(4):
    print(i)             #运行结果：0123
for i in range(1,10,2):
    print(i)             #运行结果：13579
for i in range(5,0,-1):
    print(i)             #运行结果：54321
for i in range(5,-2,-1):
    print(i)             #运行结果：543210-1

  Join的用法：

#join的用法：
s = 'adhey'
s1 = '-'.join(s)
print(s1)                #运行结果：a-d-h-e-y

　7、字典　

Python中的数据类型分为可变类型与不可变类型：

可变类型：int、str、bool、tuple.

不可变类型：list、dic、set

字典是python中非常重要的数据类型,在python中唯一一个映射的数据类型。

字典的特点：

1）字典的形式：{key,value}

2）key是唯一的且是不可变数据类型，value则可以是任意数据类型。

3）字典可以存放大量的数据，且关联性较强。

4）在Python3.5版本之前字典是无序的，但是在Python3.6版本（包括3.6）是有序的。

字典的操作包括增删改查：

字典的增：

第一种：dic[key] = value
#特点：有key就覆盖，没key就增加。
dic['name'] = '小白'
print(dic)     #运行结果：{'name': '小白', 'name_list': ['小芳','小猫']}
#第二种：dic.setdafault()
#特点：有key不变，没key就增加
dic ={'name':"小明",'name_list':['小芳','小猫']}
dic.setdefault('name1','ok')
print(dic)    #{'name': '小明', 'name_list': ['小芳', '小猫'], 'name1': 'ok'}

字典的删：

#第一种：dic.pop(key),按照key删，有返回值,返回value。
#如果要删除的key值不存在，则可以返回制定的值。
dic ={'name':"小明",'name_list':['小芳','小猫']}
ret = dic.pop('name')
print(dic,ret)   #{'name_list': ['小芳', '小猫']} 小明
#第二种：dic.clear
dic ={'name':"小明",'name_list':['小芳','小猫']}
dic.clear()
print(dic)     #{}
#第三种：del dic 删除整个字典   del dic[name]删除键值对，
dic ={'name':"小明",'name_list':['小芳','小猫']}
# del dic
del dic['name']
print(dic)    #{'name_list': ['小芳', '小猫']}
#第四种：del.popitem（）
# 随机删除有返回值以元祖形式返回被删除的值
dic ={'name':"小明",'name_list':['小芳','小猫']}
ret = dic.popitem()
print(ret)  #('name_list', ['小芳', '小猫'])
print(dic)  #{'name': '小明'}

字典的改：

字典的查：

#第一种：dic['name']
dic ={'name':"小明",'name_list':['小芳','小猫']}
print(dic['name']) #小明
#第二种：dic.get('name'),返回自己定的值，没写返回None
dic ={'name':"小明",'name_list':['小芳','小猫']}
ret = dic.get('name1')
print(ret)   #None

字典的其它操作：

#取出所有的key
dic ={'name':"小明",'name_list':['小芳','小猫']}
a = dic.keys()
print(a,type(a))#dict_keys(['name', 'name_list']) <class 'dict_keys'>
#取出所有的value
dic ={'name':"小明",'name_list':['小芳','小猫']}
a = dic.values()
print(a,type(a))#dict_values(['小明', ['小芳', '小猫']]) <class 'dict_values'>
#取出所有的键值对（可迭代的）
dic ={'name':"小明",'name_list':['小芳','小猫']}
a = dic.items()
print(a,type(a))#dict_items([('name', '小明'), ('name_list', ['小芳', '小猫'])

字典的for循环

for循环
dic ={'name':"小明",'name_list':['小芳','小猫']}
for k in dic:          #name
    print(k)           #name_list
for k in dic.keys():   #name
    print(k)            #name_list
for v in dic.values():  #小明
    print(v)            #['小芳', '小猫']
for k,v in dic.items(): #name 小明
    print(k,v)          #name_list ['小芳', '小猫']

　在循环一个字典时,如果删除某些键值对,可能会报错：

dic= {'k1':'alex','k2':'太白','k3':'日天','name':'wusir'}
#直接删除会报错
for i in dic:
    if 'k' in i:
        del dic[i]# for i in dic:  
                  # RuntimeError: dictionary changed size during iteration　　

　正确的循环时删除字典键值的方法：

#正确的删除方法
l1 = []
for i in dic:
    if 'k' in i:
        l1.append(i)
print(l1)     #['k1', 'k2', 'k3']
for k in l1:
    del dic[k]
print(dic)    #{'name': 'wusir'}

字典的特殊数据类型与list之间的转换

#字典的特殊数据类型与list之间的转换
dic = {'k1':'alex','k2':'太白','k3':'日天','name':'wusir'}
print(type(dic.keys()))     #数据类型<class 'dict_keys'>
print(type(dic.values()))   #数据类型<class 'dict_values'>
print(type(dic.items()))    #数据类型<class 'dict_items'>
print(list(dic.keys()))     #['k1', 'k2', 'k3', 'name']
print(list(dic.values()))   #['alex', '太白', '日天', 'wusir']
print(list(dic.items()))    #[('k1', 'alex'), ('k2', '太白'), ('k3', '日天'), ('name', 'wusir')]

　8、集合

1）集合是无序的，不重复的数据类型；

2）集合里面的元素必须是可哈希的，例如：int、str、bool等不可变数据类型；

3) 集合本身是不可哈希的；

4）集合里面的元素不能更改，因为集合里的元素是可哈希的；

5） 集合可以求交集、并集、差集、反交集、超集等。

 创建一个集合：

#集合的创建
set1 = set({'a','b','c'})
set1 = {1,2,'a','b'}

 集合的不可重复性：

#集合的自动去重
l1= ['a','b','b','c','c','d']
set1 = set(l1)
l1 = list(set1)
print(l1)   #把相同的元素都去除['d', 'c', 'b', 'a']

　集合的增删查：

集合的增有两种：

1）添加一个单独的元素

#单独一个元素的增
set1 = {1,2,'a','b'}
set1.add('x')
print(set1)   #元素的增{1, 2, 'b', 'x', 'a'}

2）迭代的增　

#集合迭代的增
set1 = {1,2,'a','b'}
set2 = {'a','s',5}
set2.update(set1) #将set1的内容迭代的增加到set里面
print(set2)   #{1, 's', 'a', 2, 5, 'b'}
print(set1)   #{1, 2, 'a', 'b'}
set2.update（[1,2]）
print(set2)   #{1, 2, 'a', 5, 'b', 's'}

　集合的删有四种：

#集合的删
#第一种：remove
set1 = {1,2,'a','b'}
set1.remove('a')
print(set1) #{1, 2, 'b'}
#第二种：pop
set1 = {1,2,'a','b'}
set1.pop()
print(set1)  #随机删除一个元素
#第三种：清空集合clear
set1 = {1,2,'a','b'}
set1.clear()
print(set1)  #结果：set()
#第四种：del，直接删除
set1 = {1,2,'a','b'}
del set1
print(set1)   #NameEror:name 'set1' is not defined

　集合的查：

#集合的查
#循环打印显示集合的内容
set1 = {1,2,'a','b'}
for i in set1:
    print(i)

　集合的交集、并集、差集、反交集、超集：

 交集：

#交集 'set1 & set2'或者set1.intersection(set2)
set1 = {1,2,'a','b'}
set2 = {1,2,'c'}
set3 = set1 & set2
print(set3)     #{1, 2}
set4 = set1.intersection(set2)
print(set4)     #{1, 2}

并集：

#并集  'set1 | set2'或者
set1 = {1,2,'a','b'}
set2 = {1,2,'c'}
set3 = set1 | set2
print(set3,id(set3))      #{1, 2, 'c', 'b', 'a'}  4818864
set4 = set1.union(set2)
print(set4,id(set4))      #{1, 2, 'c', 'b', 'a'}  7220680

反交集：

#反交集:'set1 ^ set2'或者‘set1.symmetric_difference(set2)’
set1 = {1,2,'a','b'}
set2 = {1,2,'c'}
set3 = set1 ^ set2
print(set3)    #{'a', 'c', 'b'}
set4 = set1.symmetric_difference(set2)
print(set4)    #{'a', 'c', 'b'}

差集：

#差集：'set1 -set2'或者’set1.difference(set2)'
set1 = {1,2,'a','b'}
set2 = {1,2,'c'}
set3 = set1 -set2
print(set3)   #{'b', 'a'}
set4 = set1.difference(set2)
print(set4)   #{'b', 'a'}
set5 = set2.difference(set1)
print(set5)   #{'c'}

超集：

#超集：'set1 < set2'或者'set2.issubset(set1)'
set1 = {1,2,'a','b'}
set2 = {1,2}
set3 = set1 < set2
print(set3)  #False
set4 = set2.issubset(set1)
print(set4)  #True
set5 = set1.issuperset(set2)
print(set5)  #True
set6 = set2.issuperset(set1)
print (set6)  #False

frozenset：

frozenset不可变集合，让集合变成不可变类型

#frozenset
set1 = {1,2,'a','b'}
s1 = frozenset(set1)
print(s1,type(s1)) #frozenset({1, 2, 'a', 'b'}) <class 'frozenset'>