python基础-基本数据类型

###基本数据类型###

#详细讲解

1.int - 整数

#概念

整数，主要用来进行数学运算

 

#操作

可以进行的操作：
    bit_length():用于计算整数在内存中占用的二进制码的长度

#例子：
i = 2
print(i.bit_length()) #打印的最小位数是2
#解释：因为十进制的2转换成2进制就是10，长度是2

i = 5
print(i.bit_length()) #打印的是3，二进制就是101

十进制   二进制      bit_length(长度)
1       0000 0001    1
2       0000 0010    2
3       0000 0011    2
5       0000 0101    3    为什么是3呢，因为101是3位数
10      0000 1010    4     4位数

 

2.bool - 布尔值

#概念

判断真假，结果只有True，和False

空值有：0,'',None,[],(),{},set() 都是False

 

#类型转换

#例1：类型之间的转换
    str => int : int(s)
    int => str: str(i)
   lst => tuple: tuple(lst)
       lst = [1,2,3]
       tu = tuple(lst)
总结点：
    1、所有的空都是False，所有的非空都是True
    2、字符串转换成数字，只能是数字
    3、想把某数据转换成其他数据类型，格式为xxx(数据)

 

3.str - 字符串

#概念

python中用',",''',"""引起来的内容称为字符串，可以保存少量数据并进行相应的操作

 

#字符串的索引和切片

###索引和切片###
#索引就是下标，从0开始
#切片的特点：
    1、顾头不顾尾
    2、只能从左往右切，但是还有第三个参数来可控制方向

#例子：
s = "改革春风吹满面"
print(s[0])   #从0开始
print(s[7])   #如果超出范围的话就会报错
print(s[-1])  #-1就是倒从后面取
print(s[1:3]) #从1切到3，但是取不到3，就是顾头不顾尾
print(s[-1:-3:-1]) # - 表示反方向，从右往左
print(s[3:6:2]) #表示从3到6中间每隔2为取一个

#字符串的相关操作

###字符串相关操作###
#注意点：字符串是不可变得数据类型，所以任何操作对源字符串是不会有影响得，需要赋值给一个变量
#例如：s = "I am a teacher" 
s.capitalize() #将首字母改为大写
print(s) #这样是不会改变得，需要赋值给变量 s1 = s.capitalize()

#字符串的大小写的互相转换
    #capitalize() :将首字母变成大写 #例子s = "this is" s1 = s.caplitalize() print(s1)
    #lower() :全部替换成小写
    #upper() :全部替换成大写
    #swapcase() :大小写互换
    #casefold() :转换成小写
    #title() : 每个被特殊字符隔开的首字母大写

#字符串的切来切去
    #center() :内容居中
    #strip() : 去掉左右两端的空格
    #lstrip() : 去掉左边的空格 l:left:左边
    #rstrip() : 去掉右边的空格 r:right 右边
    #replace(old,new) : 字符替换
    #split() : 切割

#字符串的查找
    #startswith() : 判断是否以xxx开头
    #endswith() : 判断是否以xxx结尾
    #count() : 查看某个字符出现的次数
    #find() : 查看关键字在什么位置，没有找到的话就返回-1
    #index() : 求索引的位置，如果没有找到字符串就会报错

#字符串的条件判
    #isalnum() :判断是否由字母和数字组成 number:数字
    #isalpha() :判断是否由字母组成
    #isdigit() :判断是否由数字组成
    #isdecimal() :判断是否由数字组成
    #isnumeric():判断是否由数字组成 #中文也识别

#其他
    #len() :计算字符串的长度
    #join() :将列表转换成字符串，join(里面放的是可迭代对象）
    #.format() :格式化输出

相关操作

 

4.list - 列表

#概念

列表是一个可变的数据类型，用[]方括号表示，每一项元素使用逗号隔开，列表什么都能装,能装对象的对象，可以装大量的数据

 

#列表的索引和切片

#列表的索引和切片
    列表和字符串一样，也有索引和切片，只不过切出来的内容是列表
#索引的下标从0开始，切片也是顾头不顾尾，从左往右切
#[起始位置：结束位置：步长]

 

#列表的增删改查

#注意点：列表和字符串是不一样的，list可以发生改变，所以直接就可以在原来的对象进行操作
  #例如：lst = ["张冲","蒋小雨","鲁炎"]
                  lst.append("龙大队")
                  print(lst)
#增
    append() :在后面追加  #lst.append("黑脸")
    insert(index,元素) :指定位置添加  #lst.insert(2,"黑脸")
    extend() :迭代添加，也就是一个一个添加

#删
    pop() :指定位置删除，不指定位置，默认删除最后一个
    remove(元素) :删除元素，lst.remove("张冲")
    clear() :清空列表
    del() :切片删除, del lst[1:3],因为顾头不顾尾，所以删除1和2

#修改
    索引修改: #lst[1] = "乌云",将1号元素修改成乌云
    切片修改: #lst[1:4:3] = ["龙大队"] :注意后面的步长和元素的个数不对应的就会报错

#查询
    for el in list:

 

#列表的嵌套

　　采用降维操作，一层一层的看，像洋葱一样一层一层的拨

#例子：
#lst = [1,"蒋小鱼",["鲁炎","张冲",3,["黑脸","xiaotian",4],],"太白"]
#找到张冲
#print(lst[2][1])
#找到黑脸和xiaotian
#print(lst[2][3][0:2]) #['黑脸', '龙大队'] :记住顾头不顾尾

将xiaotian拿到，然后首字母大写，再扔回去
# s = lst[3][3][2]
# s = s.capitalize()
# lst[3][3][2] = s
# print(lst)

#简写
# lst[3][3][2] = lst[3][3][2].capitalize()
# print(lst)

列表嵌套

 

#列表的相关操作

#count() :查询出现的次数
    # lst = ["蒋小鱼","张冲","鲁炎","展大鹏","黑脸","蒋小鱼"]
    # c = lst.count("蒋小鱼") #查询蒋小鱼出现的次数
    # print(c)

#sort() :排序，默认升序
    # lst = [1,2,3,44,11] #[1, 2, 3, 11, 44]
    # lst.sort()  #如果使用倒序sort(reverse=True)
    # print(lst)

#len() :列表的长度
    # l = len(lst) #计算列表的长度
    # print(l)

 

5.tuple - 元组

#概念

元组俗称不可变的列表，又称只读列表，是python的基本数据类型之一， 用()小括号表示，里面使用，逗号隔开

元组里面可以放任何的数据类型的数据，查询可以，循环可以，但是就是不能修改

 

#元组举例

#元组举例：
print((3)) #不是元组
tu = (3, ) #元组中如果只有一个元素，需要在括号里写个，逗号，否则就不是
tu = tuple() #空元组写法

#例二：不能增删改，查看索引就可以
tu = ("人民币","美元","美金","欧元")
tu.append("张三") #tuple' object has no attribute 'append'
tu[0] = "日元" #不允许修改 :object does not support item assignment
del tu[2] #报错，不允许删除：'tuple' object doesn't support item deletion
print(tu[2]) #索引就可以

 

#关于不可变的注意点

#关于不可变的注意点：
  这里元组的不可变意思是子元素不可变，但是子元素内容的子元素是可以变的
         这要取决子元素本身是否是可变
#例如
# 因为列表是可变长类型，所以可以在里面增加
# tu = (1,"蒋小鱼","鲁炎",[])
# tu[3].append("张冲")
# print(tu)
# (1, '蒋小鱼', '鲁炎', ['张冲'])

#需要注意的是，元组的第一层是不能进行赋值的，内部元素是没有要求的
#例子
#tu = (1,"巴朗","项羽","张飞") #像这样子是不能进行赋值的

 

6.dict - 字典

#概念

字典是python中唯一的一个映射类型，以{}大括号括起来的键值对组成

字典中的key是唯一的，必须是可hash，不可变的数据类型

语法：{key1:value,key2:value}

 

#演示什么数量类型能为key

#在dict中key是唯一的，在dict中存储的key-value中key必须是可hash的,不可变的数据类型
#下面将演示可为key的基本数据类型（int,str,tuple,bool是不可变的数据类型，list,dict,set是可变的)

# dic = {'name':'guoke','age':22} #字符串可以为键(key)

# dic = {1:'a',2:'b',3:'c'} #数字可以为键

# dic = {True:'1',False:'2'} #布尔值可以为键

# dic = {(1,2,3):'abc'} #元组也可以为键

# dic = {[1,2,3]:'abc'} #列表不能为键{key:vaule} 

 

#字典的增删改查

#增加
    1、变量['key'] = 'value'
             dic['广东'] = '广州'
    2、setdefault('键','值')
             dic.setdefault('广西','桂林')
          #setdefault:如果存在就不进行任何操作，不存在就添加

#删除
    1、pop()
            dic.pop('广东') ：通过key删除
    2、del dic['']
            del dic['广西'] :注意删的时候写的是key,而不是value
    3、clear() :清空 
    4、popitem() :随机删除
            dic.popitem()
    5、需要注意的是字典没有remove命令

#改
    1、dic['键'] = '值'
            dic['广东'] = '湛江' 
    2、dic.update(dic1)
            将dic1中内容更新到dic中，如果key重名就替换，否则就添加

#查
    1、使用for循环获取，得到的是键，不是值
            for d in dic:
    2、print(dic['']) ：查询键，返回值
            print(dic['广东'] :如果没有这个键就会报错
    3、print(dic.get('')) ：如果没有查询到就返回None
            print(dic.get('广东') :没有查到就返回None
    4、print(dic.setdefault(''))
            print(dic.setdefault('广东') :如果没有查到也是返回None

增删改查

 

#字典的其他操作(特有)

#keys :获取到字典中的每一个键
    print(dic.keys())
    for i in dic.keys():
#value :获取到字典中的值
    print(dic.values())
#items :获取到字典中的键值对数据
    for i in dic.items():

 

#字典的嵌套

#写字典嵌套来查找
# dic1 = {
#            "name": "汪峰",
#            "age": 18,
#            "wife": {
#                  "name": '章⼦子怡',
#                  "age": 28 },
#                  "children": ['第⼀个毛孩子', '第⼆个毛孩子'],
#                  "desc": '峰哥不不会告我吧. 没关系. 我想上头条的'
#              }

#通过key取查找，使用get
# print(dic1.get("wife").get("name")) #查找章子子怡
# print(dic1.get("wife").get("age")) #查看28
# print(dic1.get("children")[0]) #查找第一个毛孩子

#练习
# dic1 = {
#     'name':['sir',2,3,5],
#     'job':'teacher',
#     'chen':{'sir':['python1','python2',100]}
#        }
#要求
# 1，将name对应的列表追加⼀个元素’lisir’。
# 2，将name对应的列表中的sir首字⺟大写。
# 3，chen对应的字典加一个键值对’’li,’linux’。
# 4，将chen对应的字典中的sir对应的列列表中的python2删除

# s1 = (dic1.get('name'))
# s1.append('lisir')
# print(s1)

# print(dic1.get('name')[0].capitalize())

#dic1['li'] = 'linux'
#print(dic1)

# dic2 = (dic1.get('chen').get('sir').pop(1))
# print(dic2)
# print(dic1)

嵌套

 

7.set - 集合

#概念

集合：python中的一个基本数据类型，不是很常用

set集合中的元素是不可以重复的，无序的，里面的元素必须是可hash，不可变的数据类型(int,int,bool,tuple)

set集合就是不保存值的字典，如{'张三','李四'}

set集合本身就是可变的数据类型

 

#常用例子(去重)

#例子：需要使用可变数据类型，不可哈希的元素就会报错
# set1 = {'1','sir',2,True,[1,2,3]} #报错，有列表，
# set2 = {'1','sir',2,{"a":2}} #报错，有字典
# set3 = {'1','sir',{'1','sir'}} #报错，有集合

#set集合中的元素是不重复的，且无序的
# a = {"蒋小雨","鲁炎","张冲","鲁炎"}
# print(a) #{'蒋小雨', '张冲', '鲁炎'}:会去掉重复的，且不按顺序排

#####set集合最常用的就是去重###
# a = [1,3,4,4,3,2,3,4,5,5,5,45,5,254,54]
# s = set(a) #把列表转换成集合，进行去重复
# lst = list(s) #把集合转换回列表
# print(lst)
# 或者
# print(list(set(a))) #[1, 2, 3, 4, 5, 45, 54, 254]

 

#集合的增删改查

#注意点：set集合是可变的，所以可以直接在原来的对象上进行操作

#增加
    add() ：s.add("张冲")
    update(迭代更新) ：迭代就是一个一个的元素添加

#删除
    pop() ：随机删除
    remove() ：指定删除的元素
    clear()：清空，集合清空得到set(),而不是{},要和字典区分

#修改
    集合因为是无序的，没有固定的索引，所以无法直接修改元素，
        可以使用先删除后添加的方式来完成修改
#例子：
# s = {"蒋小鱼","鲁炎","张冲","阿甘"}
# s.remove("鲁炎")
# s.add("龙大队")

#查询：
    set是一个可迭代对象，所以可以使用for循环
   #for i in s:

 

#集合的常用操作

# a1 = {"蒋小鱼","鲁炎","张冲","阿甘"}
# a2 = {"刘能","赵四","张冲","谢大脚"}

#交集：就是两个集合中的共有元素
# print(a1 & a2) #{'张冲'}
# print(a1.intersection(a2)) #{'张冲'}

#并集：蒋两个集合合并起来
# print(a1 | a2) #{'张冲', '鲁炎', '阿甘', '赵四', '刘能', '蒋小鱼', '谢大脚'}
# print(a1.union(a2)) #{'张冲', '鲁炎', '阿甘', '赵四', '刘能', '蒋小鱼', '谢大脚'}

#差集：得到某一个中单独存在的
# print(a1 - a2) #{'鲁炎', '阿甘', '蒋小鱼'} :得到第一个中单独存在的，如果是a2-a1,那么得到的是第二个中单独存在的
# print(a1.difference(a2)) #{'蒋小鱼', '阿甘', '鲁炎'}

#反交集
# print(a1 ^ a2) #得到两个集合中单独存在的数据，就是两个不一样的
# #{'谢大脚', '蒋小鱼', '赵四', '刘能', '鲁炎', '阿甘'}
# print(a1.symmetric_difference(a2))
# a1 = {"蒋小鱼","张冲"}
# a2 = {"蒋小鱼","张冲","谢大脚"}

#子集: 谁是谁的子集
# print(a1 < a2) #a1是a2的子集吗？ #True
# print(a1.issubset(a2)) #True

#超集：
#如果一个集合a1中的每一个元素都在集合a2中，且集合a2中可能包含a1中没有的元素，则集合a2就是a1的一个超集。 S1是S2的超集
# print(a1 > a2) #False #a1是a2的超集吗
# print(a1.issuperset(a2)) #Flase 

常用操作