python基础二(基本数据类型)

　　python的基本数据类型:数字、字符串、列表、元祖、字典、集合

一、基本数据类型

1.1 数字int

　　数字主要是用来计算用的，使用方法并不多。

 # bit_length() 当十进制用二进制表示的时候，最少的使用二进制的位数
 i = 3
 print(i.bit_length())
 """
     1  0000 0001
     2  0000 0010
     3  0000 0011 两位
     5  0000 0101
 """

1.2 布尔型 bool

　　布尔型就两种:True(真)，False(假).

　　真 非 0  True

　　假  0     False

　注：在使用While（1）这样写执行效率比While(True) 高

 #int ------>bool 只要是0 -----> False 其余的就是True
 # while True:
 #     pass
 # while 1:
 #     效率更高

1.3字符串Str

　1.3.1 字符串的索引与切片

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

 s = "ABCDGHJHSJKAH"
 #索引 第一位是0 变量名[index]
 print(s[0])
 print(s[1])

　　切片就是通过索引（索引:索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾尾）

 a = 'ABCDEFGHIJK'
 print(a[0:3])
 print(a[2:5])
 print(a[0:]) #默认到最后
 print(a[0:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
 print(a[0:5:2]) #加步长
 print(a[5:0:-2]) #反向加步长

　　1.3.2 字符串的常见方法

 #字符串的索引与切片
 # s = "ABCDGHJHSJKAH"
 # #索引 第一位是0 变量名[index]
 # print(s[0])
 # print(s[1])
 # #字符串的切片: 顾头不顾尾 取不到最后一个值
 # s3=s[0:-1]
 # print(s3)
 # # #获取最后一位
 # # print(s[-1])
 # # #获取倒数第二位
 # # print(s[-2])
 # # print(s[0:s.__len__()]) #或者
 # # print(s[:])
 # # print(s[0:])
 # #跳着取0 2 4 加步长 s[首:尾:步长]
 # # s10=s[0:5:2]
 # # print(s10)
 # #倒着取
 # # s11=s[4:0:-1] #顾头不顾尾
 # # print(s11)
 # # print(s[3::-1])
 # # #倒序取出
 # # print(s[-1::-1])#或者print(s[::-1])
 # 字符串的操作
 s = "alexWusir"
 # 首字母大写
 print(s.capitalize())

 # 全部大写
 print(s.upper())

 # 全部小写
 print(s.lower())

 # 大小写翻转
 print(s.swapcase())
 # 乘号或者空格或者数字 隔开 隔开的单词首字母大写 并且保留空格
 s="alejdkgon-wusir  "
 print(s.title())
 # 内容居中,总长度，空拔出填充后面的填充物 #
 print(s.center(20,"#"))
 # \t 8 16 ... 如果没有内容 补空格
 print(s.expandtabs())

 # 公共方法
 print(len(s))
 # 判断前两位由什么组成
 print(s.startswith("al")) # 判断前两位以什么开头
 # 判断字符串含有y 并返回元素的索引 找不到返回-1
 # 以jdk在下标3到6之间检索
 print(s.endswith('jdk',3,6))
 print(s.find("y"))
 # index 找不到报错
 # 报错内容:ValueError: substring not found
 print(s.index("t"))
 # 去空格
 print(s.strip())
 s = ";alex;wusir;taibai" # str------>list
 # 并且会返回一个list
 print(s.split(";")) # 一分为2
 # format 的三种玩儿法  格式化输出
 res = '{}{}{}'.format('egon',18,'male')
 print(res) #egon18male
 res = '{1}{0}{2}'.format('egon',18,'male')
 print(res) #18egonmale
 res = '{name}{age}{gender}'.format(gender='male',name='egon',age=18)
 print(res) #egon18male

 # replace
 msg = 'I love China China'
 # I love female China
 print(msg.replace('China','female',1))
 # I love female female
 print(msg.replace('China','female',2))

 # is 系列
 msg = 'I have much money 12343212,just a joke -_-'
 # msg 是由纯字母组成的嘛 False
 print(msg.isalpha())
 # msg 是由纯数字组成的嘛 # False
 print(msg.isdigit())
 # msg 是由字母数字混合组成的嘛
 # False
 print(msg.isalnum())

字符串的常见操作方法

1.4 元祖

　　元祖被称为只读列表，即数据可以被查询到，但是不可以被修改。所以,字符串的切片操作同样适合于元祖

 # 元祖 只读列表,可循环查询 可切片...
 # 儿子不可以改,孙子可能可以改
 tu = (1,2,3,"alex",[2,3,4,"taibai"],"egon")
 # 修改孙子的元素
 tu[4][3] = tu[4][3].upper()
 tu[4].append("goodMan")
 print(tu)
 for i in tu:
     print(i)

1.5 列表

　　列表是python中的基本数据类型之一,其他语言中也有类似的数据类型。比如JS中的叫数组。列表是以[]括起来，每个元素之间以逗号隔开，列表里面可以存放各种数据类型 比如：

 li = ['alex',1,True,[1,2,3],(4,5,6),{'name','tom'}]

　　列表相较于字符串，不仅可以存储不同的数据类型，而且可以存储大量数据。而且列表是有序的，有索引值，可切片，方便存储。

　1.5.1 、增

 li = [1,'a','b',2,3,'a']
 # insert() 按照索引去追加
 # li.insert(0,55)
 # [55, 1, 'a', 'b', 2, 3, 'a']
 # append() 直接追加到最后面
 # li.append('hello')
 # [55, 1, 'a', 'b', 2, 3, 'a', 'hello']
 # extend() 迭代的去增加
 # li.extend(['q','w','e'])
 # li.extend(['q','w','aaa'])
 # [55, 1, 'a', 'b', 2, 3, 'a', 'hello', 'q', 'w', 'aaa']
 # li.extend('a,b,c')
 # li.extend('abc')
 # [1, 'a', 'b', 2, 3, 'a', 'a', ',', 'b', ',', 'c', 'a', 'b', 'c']
 print(li)

列表的增加

　1.5.2、删

 li = [1,'a','b',2,3,'a']
  按照位置去删除，有返回值，返回值为li[index]
 # ret = li.pop(1)
 # [1, 'b', 2, 3, 'a'] 移除li[1]
 # 按照位置去删除，也可以切片删除 没有返回值
 # del li[0]
 # 切片时首尾皆删除
 # del li[0:2]
 # 按照元素去删除，只删除查看到的第一个元素
 # li.remove('a')
 # 清空列表
 # li.clear()
 print(li)

列表的删除

　 1.5.3、改

 li = [1,'a','b',2,3,'a']
 # 改
 # 按照索引去修改
 # li [1] = ['haha']
 # 顾头不顾尾，可切片修改
 li[0:2] =['','']
 print(li)

列表的修改

　1.5.4 查

　切片去查，或者迭代去查询

　1.5.5 其他操作

 # li = [1,'a','b',2,3,'a']
 # 统计某一个字符出现的次数
 # print(li.count('a'))
 # index  用于从列表中找到某个值第一个匹配项的索引位置
 # print(li.index('a'))
 li = [1,-9,8,10]
 li.sort()
 # 从大到小 反序
 # li.sort(reverse=True)
 # 按照某一种规则排序,此处为按照绝对值之后排序
 # li.sort(key=abs)
 # 翻转
 li.reverse()
 print(li)

其他操作

1.6 字典

　　字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希值运算。根据计算的结果决定value的存储地址、所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变的数据类型。如:数字、字符串、元祖。

　　字典是出列表之外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间最大的区别在于：字典中的元素是通过键来存取的。而不是通过偏移量来存去的。

 # dict
 # 数据类型划分:  可变数据类型,不可变数据类型
 """
 不可变数据类型；元祖，bool ，int str  可哈希
 可变数据类型； list dict set
 dict key 必须是不可变的数据类型  可哈希
 value  任意数据类型
 dict 优点: 二分查找去查询
             存储大量的关系
         特点：无序的
  """

　　1.6.1、增

 dic = {'name':'jin','age':18,'sex':'male'}
 # setDefault 在字典中添加键值对。如果只有键对应的值是None。但是如果原字典中存在设置的键值对。则它不会更改或者覆盖
 # 由于存在键为name 所以值并不发生改变
 # dic.setdefault('name','baby')
 # dic.setdefault('name1','baby')
 # 直接在后面追加 []为键 后为值
 dic['tel']=12321321
 # {'name': 'jin', 'age': 18, 'sex': 'male', 'tel': 12321321}
 print(dic)

字典的增

　　1.6.2、删

 dic = {'name':'jin','age':18,'sex':'male'}
 # pop 移除键值
 # dic.pop('name')
 # 与pop的区别在于del没有返回值
 # del dic['name']
 # 随机删除字典中的某个键值对。将删除的键值对以元祖的方式返回
 ret = dic.popitem()
 # ('sex', 'male')
 # print(ret)
 # {'name': 'jin', 'age': 18}
 print(dic)

字典的删

　　1.6.3、改

 dic = {'name':'jin','age':18,'sex':'male'}
 # 更改name
 # dic['name']='angle'
 # print(dic)
 dic2 = {'name':'haha','age':26}
 # 讲dic所有的键值对覆盖添加（相同的覆盖。没有的添加）到dic2中
 dic2.update(dic)
 # {'name': 'jin', 'age': 18, 'sex': 'male'}
 print(dic2)

python的改

　　1.6.4、查

 dic = {'name':'jin','age':18,'sex':'male'}
 # 查找键为name 的值
 # ret = dic['name']
 # 同上
 # ret = dic.get('name')
 # 没有就返回None
 ret = dic.get('name1')
 print(ret)

字典的查

　　1.6.5、其他操作

 dic = {'name':'jin','age':18,'sex':'male'}
 item= dic.items()
 # dict_items([('name', 'jin'), ('age', 18), ('sex', 'male')])
 # <class 'dict_items'>
 # print(item)

 # keys = dic.keys()
 # dict_keys(['name', 'age', 'sex']) <class 'dict_keys'>
 # print(keys,type(keys))

 values = dic.values()
 # dict_values(['jin', 18, 'male']) <class 'dict_values'>
 print(values,type(values))

字典的其他操作

　　1.6.6、字典的迭代

 dic = {'name':'jin','age':18,'sex':'male'}
 for i in dic:
     print(i,dic[i])
 """
 name jin
 age 18
 sex male
 """
 for index,i in enumerate(dic):
     print(index,i,dic[i])
 """
 0 name jin
 1 age 18
 2 sex male
 """

字典的迭代

1.7 集合

　　集合是无序的，不重复的数据集合。它里面的元素是可哈希（不可变类型），但是集合本身是不可哈希的（所以集合做不了字典的键）。一下就是集合中最重要的两点:

　　　①去重，把一个列表变成集合,就自动去重复了

 set1 = set(['alex','alex',1,2,3,1,2])
 # {1, 2, 3, 'alex'}
 print(set1)

　　　②关系测试，测两组数据之间的交集、差集、并集等关系

　　

"""
集合： 可变的数据类型,它里面的额元素必须是不可变的数据类型 无序,不重复, 去重复
       {}
       增 删 查 无改的功能 无序
"""

　　1.7.1、集合的增删改查

 set1={"alex","wusir"}
 # add
 # set1.add("女神")
 # {'女神', 'wusir', 'alex'}
 print(set1)
 # update
 set1.update("abc")
 # {'wusir', 'a', 'c', 'alex', 'b'} 将abc迭代存储
 print(set1)
 # 删除
 set1.pop() # 随机删除
 print(set1)
 set1.remove("alex") # 按照元素去删除
 set1.clear() # 清空集合 空集合 set()
 del set1 # 删除整个集合

集合的增删改查

　　1.7.2、集合的关系操作

　　交集

 set1 = {1,2,3,4,5}
 set2 = {4,5,6,7,8}
 print(set1 & set2)  # {4, 5}
 print(set1.intersection(set2))  # {4, 5}

　　并集

 set1 = {1,2,3,4,5}
 set2 = {4,5,6,7,8}
 print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7,8}
 print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7,8}

　　差集

 set1 = {1,2,3,4,5}
 set2 = {4,5,6,7,8}
 print(set1 - set2)  # {1, 2, 3}
 print(set1.difference(set2))  # {1, 2, 3}

　　反交集

 set1 = {1,2,3,4,5}
 set2 = {4,5,6,7,8}
 print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
 print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

　　子集和超集

 # 子集和超集
 set1 = {1,2,3}
 set2 = {1,2,3,4,5,6}
 print(set1 < set2)
 print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。
 print(set2 > set1)
 print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集。

1.7.3、frozenset  不可变集合

 # frozenset不可变集合，让集合变成不可变集合
 s = frozenset('barry')
 print(s,type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>