二进制与十进制的转化,bool str int 之间的转化,str的常用操作,

1.基础数据类型总览(7种)

• int: 整型,用于进行+-*/运算
• str: 存储少量的数据;可加str,可乘数字,可切片,可进行9种常用操作
• bool: True False 判断真假
• list: 存储大量的数据;可进行增删改查
• tuple: 存储大量的数据，不可改变里面的元素
• dict: 存储大量的关联型的数据，查询速度非常快;可进行增删改查
• set: 自动去重;交并差集

2.int-二进制与十进制之间的相互转换

• 十进制转二进制

  • 采用"除2取余，逆序排列"法。具体做法是：用2整除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为小于1时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。

  

  42  -----> 0010 1010  #逆序排列,自右向左写,不够8位用0补齐

• 二进制转化为十进制

  • 采用二进制上的数字乘以2的位数次方,再相加.(自右向左8位依次是2**0,...2的7次方)

  0001 1010     ------> ?  26
  b = 1*2**1 + 1*2**3 + 1*2**4   #
  # print(b)  # 26

• bit_lenth() 十进制转化成二进制的有效长度(有效位数)

  # bit_lenth 有效的二进制的长度
  a = 4
  print(a.bit_lenth())
  结果为 3

3.bool str int 三者之间的转换***

• bool --- > int : True 1,False 0
• bool < --- int : 非零即True,0是False
• str --- > int : str里必须是数字,才能转
• str <--- int :均可
• bool <--- str : 非空即True
• bool --- > str : 无意义

4.str的索引,切片,步长

• 切片取值,顾头不固腚 (尾均需向尾的方向顺延1位)
• 对字符串索引,切片出来的都是字符串类型
• 从左至右有顺序，下标，索引。
• 可以倒序,但取出来的也是倒着读的str! ! !
• 不管哪种方式取值,取出来都是一个新的str,和原来的那个str没关系(即原来的s1不会因为取值而变化)

# 按索引：s1[index]
# 按照切片： s1[start_index: end_index+1]
# 按照切片步长： s1[start_index: end_index+1:2]
# 反向按照切片步长： s1[start_index: end_index后延一位:2]

#str里的四种取值方法:

#1.按索引取值
# 取出来的只有一个元素,格式:str[下标],用的是[]
# 注:按索引取值 ,规定头标是0,尾标是-1,其他元素下标既可从0往右数(正数),也可从-1往左数(倒数),都是在同一个坐标轴上移动,不过起始的参照位置不同而已。
# 注:关于正数倒数的选择,取决于你要取的元素离哪头近.
s1 = 'python全栈22期'
# s2 = s1[0]
# print(s2,type(s2))     # p    头是0
# s3 = s1[-1]
# print(s3)        # 期      尾是-1
# s4 = s1[2]
# print(s4)        # t   正数
# s5 = s1[-9]
# print(s5)        # t   倒数

#2.按切片取值-----顾头不顾尾(向尾的方向顺延1位)
# 格式:str[首:尾向尾顺延1]
# 注:尾标要向尾的方向顺延1位(正切,向右顺延,即正无穷方向)
# 注:不写步长,则默认步长为正1.
# 注:按切片取时,下标若是0,可省略不写
# 注:全取时,规定首位写成空.
# 注:头和尾的索引既可正着数(从0往右数),又可倒着数(从-1往左数);不管尾正数还是倒数,数出来后都是往尾的方向顺延一位(正切,向右顺延)!!!   重要!!!
s1 = 'python全栈22期'
# s2 = s1[0:6]
# print(s2)     # python     # 尾正着数: n的下标5,往右顺延一位(因为是正数),即为6(坐标轴)
# s3 = s1[:6]    # 0可省略不写
# print(s3)      # python
# s4 = s1[:-5]
# print(s4)      # python     # 尾倒着数: n的下标是-6(倒着数都是从-1开始往左数),往切片的尾方向顺延1位(正数,向右顺延),即为-5(坐标轴)
# 注: 首尾都是即可正数又可倒着数,看这个元素离哪头近. s2 = s1[0:6]也可写成 s2 = s1[-11:6]--蠢,此题首在最左边,所以正数比较方便.

# 全取出来
# s5 = s1[:]   # 规定:凡是全取,首尾都要写成空(不是0)! ! !有且仅有这一种写法
# print(s5)

s1 = 'python全栈22期'
# s6 = s1[6:11]
# print(s6)      # 全栈22期    #尾正着数: 期的下标是10,往尾的方向顺延1位,是11--------这种数法很蠢
# s6 = s1[6:]
# print(s6)      # 全栈22期    #尾索引倒着数: 倒数是从最后面的-1开始往左数,恰好本题的期在最后面,故期的下标是-1(不用再往左数了)。再往右顺延(正切往右顺延)1是0
# 注:首标也是既可正数,又可倒数的.s6 = s1[6:11] 也可写成 s6 = s1[-5:11]

#3.按切片步长取值（正切）
# 格式:[间隔切片的首:间隔切片的尾:步长]
# 注:切片步长只能跳着取(切片才是连着取);
# 步长=某两个间隔字符下标相减,一定是 后-前(只有间隔的字符之间才有步长)
# 注:正切,步长一定为正
# 注:因为仍是切片取值,故依然是顾首不顾尾(尾要向尾的方向顺延1位);
s1 = 'python全栈22期'
# s2 = s1[:5:2]    # pto      # 尾标正数: o的下标4,往尾的方向顺延1位(正切,往右顺延),即为5
# print(s2)
# s3 = s1[:-6:2]  # pto      # 尾标倒数: 凡是倒数,都是从最后面的-1开始往左数,故o的下标为-7,再往切片尾的方向(正切,尾往右顺)顺延1位,即为-6
# print(s3)
# 小结:不管尾标是正着数还是倒着数,数出来下标后,正切都是往右顺延1位(因为正向切片的尾在右边)
# 注:因为要取出的str首标在最左边,故正数方便

#4.反向按切片步长取值(反切)
# 格式:str[倒序的首标:倒序的尾标:步长(倒序步长一定为负)]
# 注:反切,步长一定为负
# 注:取出来的str是倒序!!!
# 注:反切,切片的首标(正切的尾是此时反切的头)规定一定要倒着数,即从-1开始往左数 ! ! !
# 注:反切,尾标既可正数也可倒着数,但是数出来后都要往尾的方向顺延1位(反切,向左顺延)
# 注:仍是顾首不顾尾(尾要向尾的方向顺延1位);
s1 = 'python全栈22期'
# s2 = s1[-1:-6:-1]
# print(s2)          # "期22栈全" (倒序)    # 首标必须倒数,尾标可正可倒,最后都要往尾的方向顺延1位(反切,向左顺延,因为反向切片的尾在左边)
# s3 = s1[-1:5:-1]
# print(s3)           # "期22栈全" (倒序)   # 尾标正数,全从左0向右数是6,再向反切切片尾的方向顺延1(反切,尾向左顺延),即为5.
# 本题小结:a.不管尾标正数还是倒着数,数出来下标后,尾都要往切片尾的方向顺延1位(反切,向左顺延).
# b.反切的头标规定只能倒着数,即从-1开始往左数,尾标既可正数又可倒数,根据尾元素离哪头近来决定.

s1 = 'python全栈22期'
# s4 = s1[-4:-6:-1]
# print(s4)          #"栈全"    # 首标必须倒着数,反切切片的尾标:倒数为-5,再向切片的尾顺延1位为-6(反切,向左顺延)
# s5 = s1[-4:5:-1]
# print(s5)          #"栈全"    # 首标必须倒着数,反切切片的尾标:正数为6,再向切片的尾顺延1位为5(反切,向左顺延)

# 反切全取
s1 = 'python全栈22期'
# s6 = s1[::-1]
# print(s6)         # 期22栈全nohtyp    # 仅此一种取法
# 注:全切规定首尾都为空,但步长一定为负值!

#思考题:倒序全部取出来?
# s10 = s1[-1:-12:-1]
# print(s10)------取出"期22栈全nohtyP"     注:倒序的首是期,期的下标是-1,则倒序的尾p的下标为-11加1=-12(即从-1往后数,想坐标轴)

# 小结:4种取值方式---注意事项汇总
# a:按索引取,头是0,尾是-1;每个元素均既可正数又可倒着数;
# b:按切片取,只有正切; 首标尾标也是 均既可正数又可倒着数;全切,头尾都是空(规定);
# c.按切片步长取,只有正切,步长为正; 首标尾标既可正数又可倒着数; 全切,头尾都是空[::2],步长自定;
# d.按反向步长取(即反切),只有反切,步长一定为负; 切片的首标只能倒着数(从-1往左数),尾标可正可倒;全切,头尾都是空[::-2],步长自定;
# 注:切片,切片步长,反向切片步长取值,都是顾首不顾尾,尾都要向尾的方向顺延1位。（正切:尾标往右顺延;反切:尾标往左顺延）
# 小结:str,list,tuple 都有索引,切片;python中用的最多的3种数据类型是,使用频率:dict > list >str

5.str的9种常用操作方法(2对+7个):

• 这2对+7个均不会对原字符串进行任何操作，都是产生一个新的字符串
• 记忆口诀:7个的"换去分格数加十"
• 写在前面: 9种操作,均要对其操作进行赋值再打印,才能更改;或者直接打印操作,才能更改.(因为修改后的会形成1个新的str,跟原来的str没关系)

# 1.upper lower(第一对)
# 作用:达到不区分大小写的目的
# 应用:当用户输入验证码时可达到不区分大小写的目的(见下面eg)
# 格式:"字符串.upper()"或"变量.lower()"
s = 'taiBAifdsa'
# s1 = s.upper()
# print(s1,type(s1))    # TAIBAIFDSA
# s2 = s.lower()       # taibaifdsa
# print(s2)

# 应用：
# username = input('请输入用户名')
# password = input('请输入密码')
# code = 'QweA'    #------------------为了让用户不管输入大写还是小写都能通过验证!
# print(code)
# your_code = input('请输入验证码：不区分大小写')
# if your_code.upper() == code.upper():   #应用它!  #用upper或者lower都能达到目的.
#     if username == '太白' and password == '123':
#         print('登录成功')
#     else:
#         print('用户名密码错误')
# else:
#     print('验证码错误')

# 2.startswith  endswith(第二对)
# 作用:判断str是否以(某元素)开始,是否以(某元素)结束;返回True False
# 格式:字符串.startswith("某元素")
# 应用:
# s = 'taiBAifdsa'
# print(s.startswith('t'))       # True
# print(s.startswith('taiBAi'))     # True
# # 了解:
# print(s.startswith('B',3,6))     # True 不懂
#
# s = 'taiBAifdsa'
# print(s.endswith('a'))       # True
# print(s.endswith('BAifdsa'))       # True

# 3.replace
# 作用:替换
# 格式:"字符串.replace("old变量","new变量",替换次数)"------注:若不输入次数,则默认全部替换
msg = 'alex 很nb,alex是老男孩教育的创始人之一，alex长得很帅'
# msg1 = msg.replace('alex','太白')  # 默认全部替换
# print(msg1)
# msg2 = msg.replace('alex','太白',2)   # 只替换从左数的前两个alex
# print(msg2)

# 4.strip
# 作用:去除" "里的空白或\t(空格符)和\n(换行符)  #只能去前后的.中间的去不了.eg:"5+         7"就不行.
# 格式:"字符串.strip()"
# s1 = '           太白\t\n'
# print(s1)   # 通过鼠标去看哪有空格
# s2 = s1.strip()
# print(s2)
# 了解:
# 可以去除指定的字符
# s4 = 'rre太r白qsd'
# s5 = s4.strip('qrsed')    # 太r白  #()是要去掉的字符
# print(s5)

# 5.split 分割符    ***(重要!)
# 作用:将一个str分割为list
# 格式:a.默认分隔符:"字符串.split("")"用空格划分(但前提是原str里有空格)
# b.指定分隔符:"字符串.split("字符串里含有的符号or元素")"-->代表将这个str用这个指定的符号or元素划分,分割后是list !!!
# str ---> list
# s6 = '太白 女神 吴超'
# print(s6.split(' '))    # ['太白', '女神', '吴超']
# s7 = '太白:女神:吴超'
# print(s7.split(':'))    # ['太白', '女神', '吴超']
# 注:分割出来就已是个list!!!
# 了解：
# s8 = ':barry:nvshen:wu'
# print(s8.split(':'))     # ['', 'barry', 'nvshen', 'wu']
# print(s8.split(":",2))   # 只分割自左至右的前2个    # ['', 'barry', 'nvshen:wu']

# 6.join 非常好用
# 作用: 将list(所有元素必须都是str) 或str里的元素用某个符号串起来
# 格式:"某符号".join(str或list)
# 前提：列表里面的元素必须都是str类型,才可加
# s1 = 'alex'
# s2 = '+'.join(s1)   # 用"+"把字符串"alex"的各元素加起来
# print(s2,type(s2))     # a+l+e+x
# l1 = ['太白', '女神', '吴超']
# s3 = ':'.join(l1)  # 用":"把list['太白', '女神', '吴超']里的各元素加起来
# print(s3)     # 太白:女神:吴超

# 7.count
# 作用: 数某个字符在这个str中出现的次数
# s8 = '我是hhhs呀'
# print(s8.count('h'))    # 3
# print(s8.count('hs'))   #也可是多个字符

# 8.format: 格式化输出-----跟%s作用相同,但用法不同
# 第一种用法：{}相当于%s
# msg = '我叫{}今年{}性别{}'.format('大壮',25,'男')   # 要一一对应
# print(msg)
# 第二种用法：按索引格式化
# msg = '我叫{0}今年{1}性别{2}我依然叫{0}'.format('大壮', 25,'男')    # 要一一对应,但最后一个不用写
# print(msg)
# 第三种用法：给变量赋值格式化   #指名道姓去填充
# 注: .format()的括号里给变量赋值的顺序可以乱序
# a = 100
# msg = '我叫{name}今年{age}性别{sex}'.format(age=a,sex='男',name='大壮')   # 可乱序
# print(msg)

# 9.is 系列：
# 作用:判断str是否由整数组成等等(返回true false)
# is 系列：
# name = 'taibai123'
# print(name.isalnum()) #字符串是否由字母or数字or中文(漏洞)组成
# print(name.isalpha()) #字符串是否 只由字母or中文(漏洞)组成,字母+中文都是true
# print(name.isdecimal()) #字符串是否 只由十进制组成      # 常用! 重要!!!
# 注:name = '100①' #isdigit()见到①,也视为数字.-不报错(漏洞:①是符号,不是数字)

# 应用:
# s1 = input('请输入您的金额：')
# if s1.isdecimal():   # 判断输入的金额是否只由整数(整型int)组成
#     print(int(s1))
# else:
#     print('输入有误')

# 注:忘记单词咋写时,可以在pycharm中,通过用数据类型把变量包起来的方法去查看这种数据类型的多种使用方法 eg:a = "taibai" , 通过str(a).  来查看str的多种使用方法

6.for循环

• 可迭代对象:

  • 凡是可迭代对象,均可遍历
  • 除了int,bool不可遍历;其他数据类型(str list tuple dict set)均可遍历,叫可迭代对象;range()也是可迭代对象

• 坑:

  • 若print与for平齐,则只打印可迭代对象的最后一个元素

    s = "taibai667"
    for i in s:
        # print(i)
        # ...    #...和pass用法一样,都是占位符(过)
        pass
    print(i)  #7  打印的只是str的最后1个元素