第四章 数据基本类型

1.整数

123  # 计算和比较
14  0  # 十进制
7   1
3   1
1   1
128 64 32 16 8 4 2 1
print(2**0)  1
print(2**1)  1
print(2**2)  1
print(2**3)  1
print(2**4)  1
print(2**5)  1
print(2**6)  1
print(2**7)  1
num = 7   # 8421   00000111
print(num.bit_length())  # 求十进制数转换成二进制时所占用的位数

1. 判断是不是阿拉伯数字

   name = "②"
   print(name.isdigit())  # 判断是不是阿拉伯数字

2. 判断是不是十进制 -- 用它来判断是不是数字

    name = "666"
    print(name.isdecimal()) # 判断是不是十进制  -- 用它来判断是不是数字

3. 判断的是中文和字母

   name = "alexs你好"
   print(name.isalpha())    # 判断的是中文和字母

4. 判断的是不是字母，中文和阿拉伯数字

   name = "alex666"
   print(name.isalnum())   # 判断的是不是字母，中文和阿拉伯数字

2.布尔值

bool # 布尔值 -- 用于条件使用
True  真
False 假
print(bool(-10))       # 0 是 False             非0的都是True
print(bool(" "))       # 空的字符串是 False      非空的就时True
print(type(str(True))) #布尔值可以转换成字符串
print(int(False))      # True 转化成数字 1   False 转换成数字 0

3.字符串

# 字符串 -- 用于存储数据的 -- 比较少
# python 中只要是用引号 引起来的就是字符串
""
''   # 需要配合使用
""" """
''' '''

name = "meet，alex，wusir，wangsir，Eva_j"
      01234567  (索引)     #从左向右数数
     -4-3-2-1 （索引） # 从右向左数数

a = name[1]
b = name[2]
print(a + b)
print(name[5:9])  # 区间[起始位置：终止位置]  # 顾头不顾尾

a = name[0]
b = name[3]
c = name[6]
d = name[9]

print(a+b+c+d)
print(name[0:10:3])
#默认是1   [起始位置：终止位置：步长]  # 你走路迈的步子
#起始位置 + 步长

 print(name[0:100])  # 切片如果终止位置超出了不报错
 print(name[100])    # 索引取值的时候超出了索引的范围会报错
 print(name[::])
 print(name[::-1])  #从左向右  +1  从右向左
 
 a = name[8:11]
 b = name[16:19]
 c = name[-3:]
 # 李亚鹏 谢霆锋 陈冠希

 print(c,b,a)
 print(name[::3])
 name = "周扒皮，王菲，陈冠希，张柏芝，谢霆锋，周星驰，李亚鹏"

 总结：
     字符串，列表，元组  --  都是有索引（下标）
     索引是准确的定位某个元素
     从左向右 0,1,2,3
     从右向左 -1，-2，-3，-4
     支持索引的都支持切片   [索引]
     切片长度可以超出范围，索引长度不能超出范围  [起始位置：终止位置]
     步长： 决定要走的方向，决定走的步子多大  [起始位置：终止位置：步长]
     # 起始位置 + 步长

字符串方法：

1. 全部大写:

   name = "meet"
   name1 = name.upper()
   print(name1)

2. 查看内存地址:

   print(id(name))
   print(id(name1))

3. 全部小写:

   name = "MEET"
   name1 = name.lower()
   print(name1)

大小写例子:

yzm = "o98K"
input_yzm = input("请输入验证码（o98K）：")
if yzm.upper() == input_yzm.upper():
    print("正确")
else:
    print("错误")

1. 判断以什么开头:

   name = "alex"
   print(name.startswith('a'))  # 就是以a开的头

2. 判断以什么结尾:

   name = "zhuxiaodidi"
   print(name.endswith("i"))   # 就是以i结尾

3. 统计

   name = "zhudidi"
   print(name.count("zhu")) 

4. 替换

   name = "alexnbnsnsn"
   name1 = name.replace('n','s')  # 替换
   name1 = name.replace('n','s',2)  # 替换  2是替换的次数
   print(name1)

5. 除去头尾两边的空格

   name = " alex   "
   name1 = name.strip()  # 可以写想要去掉的内容
   print(name1)
   if name == "alex":
       print(666)
   name = "   alex     "
   print(name.strip())

6. 分割

   name = 'alex，wusir'
   print(name.split("w"))
   #默认是以空格分割 ,也可以自己制定分割
   #分割后返回的内容是一个列表

4.列表

1. 列表初始

    什么是列表?
    list  []  多个元素 每个元素中间用,逗号隔开
    s = "1234Trueabc"  #类型单一
    定义方式一:  常用
    li = [1,2,3,'123',True,[1,2,5]]   # 容器
    列表 == 书包
        水杯
        衣服
        袜子
        钱包
            1,2,5
    容器存放的类型是多种,任意类型都可以放到容器中
    定义方式二:
    li = list("abc")  #底层使用了for循环  "abc" 可迭代的字符串类型
    print(li)
    列表能干啥?
    存储大量数据,字符串存储少量数据的
    有序的?  按照咱们写的顺序输出
    可变的 -- 可以在本身上进行修改

2. 列表切片

   如何使用列表?
   s = "123"
   print(s)
   li = [1,2,3,"123",True]
     # 0 1 2  3     4
   print(li)
   有序支持索引
   print(li[3],type(li[3]))
   print(li[-1],type(li[-1]))
   li = [1,2,3,"123",True]
    # 0 1 2   3      4
    # -5 -4 -3  -2    -1
   有序支持切片
   print(li[1:4])
   支持步长
   s = "alex"
   print(type(s[1:3:1]))   # 切片后还是原来的数据类型
   print(type(li[-1:-4:-1]))
   li = [1,2,3,"123",True,[1,2,3,False],]
   print(li[-1:-4:-2])  # 起始 + 步长 -1 + -2  = -3  + -2 = -5
   列表是有序的:
       支持索引 ,切片,步长
   列表是可变的:
        增加 - 删除 - 修改
   
   索引 切片 步长 ---  你取几个,就放几个  不能多不能少
   li = ["水杯",2,3,"abc",]
   li[0:3:2] = [1,2,3],[1234]
   print(li)
   a,b = [1,23],[3,45]
   print(a,b)
   a = 1
   b = 2
   a = 2  b = 1
   a,b = b,a
   print(a,b)

3. 增

   追加到末尾:

   li = [1,2,3,'alex',3,[1,2,3]]
       # 0,1,2,  3,    4, 5
   li.append('太亮')             # 追加  添加在末尾  添加的操作
   print(li)

   插入:

   li.insert(0,"大象")           # 插入 第一个参数(索引),第二参数要插入的内容
   效率特别低
   print(li)

   扩展---迭代:

   li.extend("abc")                # 扩展 -- 迭代添加  -- for
   print(li)
   li = [1,2,3]
   li.extend("abc")
    迭代添加开始
    for i in "abc":
        li.append(i)
    迭代添加结束
    print(li)

   列表的合并:

   l3 = [1,2,3]
   l2 = ["a","b","c"]
   l4 = l3 + l2  # 列表合并
   print(l4)
   [1,2,3,["a","b","c"]]

4. 删

   pop删除:

   li = [1,2,3,"abc",True]
   print(li.pop(3))
   # 弹 pop有返回值  返回的是被删除的内容
   # 默认删除的是最后一个
   # 可以通过索引指定删除
   print(li)

   remove移除:

    li.remove(1)   # 删除   按照元素名进行删除
    print(li)

   del删除:

   li = [1,2,3,"abc",True]
   del 关键字
   del li   # del li 将整个容器都删掉了
       del li[2]   #del 支持索引删除
   del li[0:3]   #del 支持切片删除
   del li[::2]    # del 支持步长删除
   print(li)

   clear清空:

   li = [1,2,3,43]
   li.clear()  # 清空
   print(li)

5. 改

   li = ["水杯",2,3,"abc",]
   l2 = [1,2,3,4,66,7]
   # li[-1] = "奶瓶"
   # li[1] = [1,2,3]
   # li[1:2] = []  #[66,7]  # 迭代进去的 可以多,可以少
   print(li)

6. 查

    li = [1,2,3,4]
    print(li)
    print(li[1])
    for 循环
    for em in li:
        print(em)

7. 列表的嵌套

    列表的嵌套:
   li = ["水杯","衣服","鞋子","书","电脑","屁",["手机","钥匙",["身份证","银行卡"]],]
   l2 = li[6]
   l3 = l2[2]
   print(l3[0])
   li[6]  == ["手机","钥匙",["身份证","银行卡"]]
   li[6][2] == ["身份证","银行卡"]
   print(li[6][2][0])
   li = ["高圆圆","吴奇隆","汪峰",
         ["国际章","张曼兮","龙泽罗拉"],
         "陈冠希",
         ["张柏芝","阿娇",["熊哥",["一本道"],"亮哥",["北京热"],"
         怼哥",["动物园"],"奇奇",["大象"]],"大S",["小S"],"范冰冰"],
         "周星驰",["逃学威龙","功夫","大话西游"]]
   print(li[5][2][1])
   print(li[5][2][-1][0])
   li = [1,2,3,4,1,2]
   li.remove()
   print(li)

5.元组

他是什么?

 元组  tuple
 tu = ("1")  # ()  每个元素都以 逗号隔开
 tu1 = (1)
 小括号中一个元素的时候没有逗号就括号中元素的本身
 小括号中一个元素的时候有个逗号就是元组
 空的小括号就是元组
 print(type(tu1))
 元组有序:
     索引,切片,步长
 元组不可变数据类型
tu = (1,2,3)
print(tu[1])
元组只能查看不能修改   -- 元组和列表相似,元组是不可修改的
他能干啥?
存储一些你不想让别人修改的数据  - 元组容器 存储一些任意类型
在哪干?
在配置文件中,程序中  为了防止误操作修改一些数据

1. 元组的嵌套

   tu = (1,2,3,(4,5,6,[6,7,8,(9,11,10),"abc"],"ABC"))
   print(tu[3][3][3][1])  # [6,7,8,(9,11,10),"abc"]
   print(tu[-1][-2][-1])