python基础数据类型----整数 ,字符串【常用操作方法】,布尔值，for循环

python基础数据类型（4.29）

• bool str int 三者之间的转换
  
• str索引切片，常用操作方法
• for循环（大量的练习题）

1.基础数类型总览

• 整数(int) ,字符串(str),布尔值(bool),列表(list),元组(tuple),字典(dict),集合(set).
  • 10203 123 3340 int 主要用于计算+- * / 等等
  • '今天吃了没？' str 存储少量的数据，并进行相应的操作。str1 + str2， str *int ， 索引，切片， 其他操作方法
  • true false bool 判断真假
  • [12, true, 'alex', [1,2,3 ]] list 存储大量有序数据。列表内部数据可任意改动
  • (12, true, 'alex', [1,2,3 ]) tuple 存储大量的数据，元组不可改变里面的元素。只读，不能更改。
  • {'name': '太白金星'} dict 字典存储大量的关联性比较强的数据，查询速度非常快。
  • set 集合

2.数字int

• 十进制二进制转换
  
  #二进制转换成十进制
  0001 1010     ------>   26
  
  b = 1 * 2**4 + 1 * 2**3 + 0 * 2**2 + 1 * 2**1 + 0 * 2**0
  print(b)  # 26
  
  
  #十进制整数转换成二进制整数 
  42  -----> 0010 1010    除2取余，逆序排列
  
  #十进制小数转换成二进制小数  
  乘2取整，顺序排列：用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，此时0或1为二进制的最后一位。或者达到所要求的精度为止。
  0.625 = (0.101)b
  0.625 * 2 = 1.25 ---->1
  0.25 * 2 =0.5    ---->0
  0.50 * 2 =1.0    ---->1
  

• bit_lenth 十进制转化成二进制的有效长度【bit_length()计算整数在内存中占用的二进制码的长度.】

  # bit_lenth 有效的二进制的长度
  i = 4
  print(i.bit_length())  # 3
  i = 5
  print(i.bit_length())  # 3
  i = 42
  print(i.bit_length())  # 4

3.布尔值bool：true false

• bool str int 三者之间的转换

  数据类型之间的转换：
  ##### bool  <---> int #######
  #bool-->int  :true    1   false     0
  print(int(true))  # 1
  print(int(false))  # 0   
  
  #int-->bool  :非零即true ,0 为 false
  i = 0
  print(bool(i))
  
  【重点】##### str   <--->   int  #####
  # str ---> int  : 只能是纯数字组成的字符串可以转化成数字类型
  s1 = '1088'     
  print(int(s1))  # 字符串引号内必须是数字组成 
  # int ----> str  所有数字都能转化成字符串
  i = 100
  print(str(i),type(str(i)))
  
  【重点】###### str <---> bool ##### 
  # str--->bool :非空即true
  s1 = ' '  #空格，不是空
  print(bool(s1))  #true
  
  s1 = ''  # 空字符串,为false
  print(bool(s1))   #false
  
  # bool  ---> str  无意义
  print(str(true), type(str(true)))  # 运行结果：true <class 'str'>
  

  • 应用：

  s = input('输入内容')   #input输入的为字符串类型
  if s:                #（字符串作为布尔值进行判断）
      print('有内容')
  else:
      print('没有输入任何内容')
  #直接回车，显示“没有输入任何内容”
  #先空格，再回车，显示“有内容”

4.字符串str（重点）

• python中凡是用引号引起来的数据可以称为字符串类型，组成字符串的每个元素称之为字符，将这些字符一个一个连接起来，然后在用引号起来就是字符串。

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

• 切片：切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串

• 对字符串进行索引和切片，出来的数据都是字符串类型。

• 常用操作方法:字符串的常用操作方法,不会对原字符串进行任何操作，都是产生一个新的字符串

  • 索引切片步长

  #字符从左至右有顺序，依次为0，1，2....。从右往左以次为-1，-2，-3，....
  s1 = 'python全栈22期'
  
  # 按照索引取值，每次取一个字符。索引即下标index
  s2 = s1[0] 
  print(s2)          #p
  print(s2,type(s2)) #p <class 'str'>
  s3 = s1[2]
  print(s3)          #t
  s4 = s1[-1]
  print(s4)          #期
  
  # 按照切片取值。按照切片取值，原则：顾头不顾腚
  s5 = s1[0:6]
  s5 = s1[:6]  #从开头开始取，0可以默认不写
  print(s5)   #python
  s6 = s1[6:]
  print(s6)   #全栈22期
  print（s1[:-1] #python全栈22 
                 #-1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到'期'元素
  
  # 切片步长
  s7 = s1[:5:2]  #加步长
  print(s7)     #pto
  print(s1[:])  ##开头到最后，python全栈22期
  
  # 倒序：
  s8 = s1[-1:-6:-1]  ##反向加步长
  print(s8)     #期22栈全
  
  # 倒序全部取出来
  s9 = s1[-1::-1]
  print(s9)    #期22栈全nohtyp
  
  s9 = s1[::-1]
  print(s9)    #期22栈全nohtyp
  
  s9 = s1[-1:0:-1]  #错误
  print(s9)    #期22栈全nohty  没有字母p 
  
  
   按索引：s1[index]   注释：index下标
   按照切片取值： s1[start_index: end_index+1]
   按照切片步长取值： s1[start_index: end_index+1: step]
   反向按照切片步长取值： s1[start_index: end_index后延一位: step]
  
  

• 练习题

  '''
  有字符串s = "123a4b5c"
  通过对s切片形成新的字符串s1,s1 = "123"
  通过对s切片形成新的字符串s2,s2 = "a4b"
  通过对s切片形成新的字符串s3,s3 = "1345"
  通过对s切片形成字符串s4,s4 = "2ab"
  通过对s切片形成字符串s5,s5 = "c"
  通过对s切片形成字符串s6,s6 = "ba2"
  '''
  
  s = "123a4b5c"
  s1 = s[0:3]
  s1 = s[:3]
  print(s1)
  s2 = s[3:6]
  s2 = s[-5:-2]
  print(s2)
  s3 = s[0:-1:2]
  print(s3)
  s4 = s[1:6:2]
  print(s4)
  s5 = s[-1]
  print(s5)
  s6 = s[-3:0:-2]
  print(s6)
  

  • 常用操作方法【重点】

  字符串的常用操作方法,不会对原字符串进行任何操作，都是产生一个新的字符串
  
  
  upper lower
  #例
  s = 'taibaifdsa'
  s1 = s.upper()   #字符串s中字符全部大写（不会对原字符串进行任何操作，都是产生一个新的字符串
  print(s1,type(s1))  #taibaicbr
  s2 = s.lower()    #字符串s中字符全部小写
  print(s2,type(s2))   #taibaicbr
  
  # 应用：
  username = input('用户名')
  password = input('密码')
  code = 'qwea'
  print(code)
  your_code = input('请输入验证码：不区分大小写')
  if your_code.upper() == code.upper():
      if username == '太白' and password == '123':
          print('登录成功')
      else:
          print('用户名密码错误')
  else:
      print('验证码错误')
  
  
  
  startswith    endswith
  #startswith 判断是否以...开头
  s = 'taibaifdsa'
  print(s.startswith('t'))        #true ***【重点】 判断是否以单个字符开头
  print(s.startswith('taibai'))   #true ***【重点】 判断是否以多个字符开头
  print(s.startswith(' '))        #false 判断是否以空格开头
  
  #endswith 判断是否以...结尾
  s = 'taibaicbr'
  s1 = s.endswith('t')
  print(s1)  #false，返回的是布尔值
  s2 = s.endswith('br')
  print(s2)  #true
  
  # 了解
  s = 'taibaifdsa'
  print(s.startswith('b',3,6))   #true   括号内的字符串必须加引号'b'
                                 #切片，顾头不顾腚。判断'bai'是否以b开头。下标3，6，不包括6对应的f。
  s = 'taibaifdsa'
  print(s.endswith('f',3,6))    #false
  
  
  
  replace(old,new,count)
  #讲
  msg = 'alex 很nb,alex是老男孩教育的创始人之一，alex长得很帅'
  msg1 = msg.replace('alex','太白')  # 默认全部替换,用'太白'替换'alex'
  msg1 = msg.replace('alex','太白',2)   #用'太白'替换'alex',2表示只替换前两个字符串
  print(msg)  #alex 很nb,alex是老男孩教育的创始人之一，alex长得很帅
  print(msg1) #太白 很nb,太白是老男孩教育的创始人之一，alex长得很帅
  
  #自
  msg = '小明生病了，小明没去上学，小明在家休息'
  msg1 = msg.replace('小明','小红')
  print(msg1)  #小红生病了，小红没去上学，小红在家休息
  msg2 = msg.replace('小明','小红',2)
  print(msg2)  #小红生病了，小红没去上学，小明在家休息
  
  #自：比如某个字母小写变大写，大写边小写
  s = ' qw sertyu eqtrti '
  s1 = s.replace('t','t',2)
  print(s1)# qw sertyu eqtrti
  
  
  
  strip:去除空白，如空格，\t制表符， \n换行符。
  # \n(换行符-将光标移动到下一行的开头)
  # \t(水平制表符-将光标向右移动一个制表符位)
  
  #默认去除字符串两边的空格，换行符，制表符
  s4 = '  \n太白\t'
  print(s4)
  s5 = s4.strip()
  print(s5)
  #修改测试
  s4 = '  \n太 白 tai \tbai\t'
  print(s4)
  s5 = s4.strip()
  print(s5)#太 白 tai     bai   #只能去掉两边的空白，内部的去不掉
  
  
  
  name='*barr*y**'
  print(name.strip('*'))  # barry
  print(name.lstrip('*'))  # barry**
  print(name.rstrip('*'))  # *barry
  #修改测试
  name='*barr*y**'
  print(name.strip('*'))  # barr*y   #只把两边的*去掉了，内部的*去不了。
  print(name.lstrip('*'))  # barr*y**
  print(name.rstrip('*'))  # *barr*y
  
  # 了解：可以去除指定的字符
  s4 = 'rre太r白qsd'
  s5 = s4.strip('qrsed')  #括号内字符串加引号,字符顺序无所谓
  print(s5)  #太r白     #只能去两头的对应字符
  
  
  split  【非常重要】以什么分割，最终形成一个列表，此列表不含有这个分割的元素。
  # str ---> list  字符串类型转换为列表类型，- 默认按照空格分隔，可以指定分隔符。
  
  # 默认按照空格分隔，返回一个列表
  s6 = '太白 女神 吴超'
  l = s6.split()
  print(l)  #['太白', '女神', '吴超']
  
  # 指定分隔符
  s6 = '太白:女神:吴超'
  l = s6.split(':')   #  :作为分隔符
  print(l)  #['太白', '女神', '吴超']
  
  ret9 = 'title,tilte,atre,'.split('t')  # t作为分隔符
  print(ret9)  #['', 'i', 'le,til', 'e,a', 're,']  ''空字符
  
  # 了解：
  s6 = ':barry:nvshen:wu'
  print(s6.split(':'))    #['', 'barry', 'nvshen', 'wu']  注：''空字符串
  print(s6.split(":",2))  #['', 'barry', 'nvshen:wu']  #2表示前两个：有效
  
  #自-实验
  s1 = ' .haha.heihei.hehe.123'
  s2 = s1.split('.')   # .作为分隔符
  s3 = s1.split('.',3)
  print(s2)  #[' ', 'haha', 'heihei', 'hehe', '123']  注：' ' 引号内为空格
  print(s3)  #[' ', 'haha', 'heihei', 'hehe.123']
  
  
  
  join（iterable）：联合，连接，可以操作任何可迭代对象（可迭代：这个数据由多个元素组成，如字符串，列表），     
  
  s1 = 'alex'
  s2 = '+'.join(s1)   #'设置连接符'.join(iterable)  iterable可迭代  用+作为连接符
  print(s2）   #   a+l+e+x（字符串类型）
  print(s2,type(s2))  # a+l+e+x <class 'str'>
  
  #list ---> str  前提：列表里面的元素必须都是str类型才行
  l1 = ['太白', '女神', '吴超'] 
  s3 = ':'.join(l1)   #用：作为连接符
  print(s3)   #  太白:女神:吴超(字符串类型)
  print(s3,type(s3)) #太白:女神:吴超 <class 'str'>
  
  
  
  count
  #count数出字符串中的元素出现的个数。
  s8 = 'sdfsdagsfdagfdhgfhgfhfghfdagsaa'
  print(s8.count('a'))  #5，5是数字类型
  s9 = s8.count("a",0,11) # 可切片，索引0,11不包含11
  print(s9)             #2
  
  
  format: 格式化输出
  # 第一种用法：
  msg = '我叫{}今年{}性别{}'.format('大壮',25,'男')
  # 第二种用法：
  msg = '我叫{0}今年{1}性别{2}我依然叫{0}'.format('大壮', 25,'男')
  print(msg)
  # 第三种用法：
  a = 100
  msg = '我叫{name}今年{age}性别{sex}'.format(age=a,sex='男',name='大壮')  #此处format（）内可以不按顺序
  print(msg)
  
  
  is 系列： 返回布尔值
  name = 'taibai123'
  name = '100①'
  print(name.isalnum()) #字符串由字母或数字组成
  print(name.isalpha()) #字符串只由字母组成
  print(name.isdecimal()) #字符串只由十进制组成
  
  #应用
  s1 = input('请输入您的金额：')
  if s1.isdecimal():
       print(int(s1))
  else:
       print('输入有误')
  
  补充：
  #寻找字符串中的元素是否存在
  a4 = "dkfjdkfasf54"
  ret1 = a4.find("fjdk",1,6)
  print(ret1)  #2 返回的找到的元素的索引，如果找不到返回-1
  ret2 = a4.index("fjdk",2,6)
  print(ret2) #2 返回的找到的元素的索引，找不到报错。
  ret2 = a4.index("fjdk",4,6)
  print(ret2)#报错
  
  #captalize,swapcase,title
  name='taibaihi123'
  print(name.capitalize()) #taibaihi123   首字母大写
  print(name.swapcase()) #taibaihi123     大小写翻转
  msg='taibai say hi'
  print(msg.title()) #taibai say hi  每个单词的首字母大写
  
  # 内同居中，总长度，空白处填充
  ret3 = a4.center(22,"*")
  print(ret3)#*****dkfjdkfasf54*****
  
  
  
  

5.for循环:有限循环

s1 = '老男孩edu'
print('老' in s1)   #true   成员运算符
print('老男' in s1)   #true
print('老ed' in s1)   #false
print('老ed' not in s1)  #true

s1 = '老男孩教育最好的讲师：太白'

输出：
'''
老      s1[0]
男      s1[1]
孩      s1[2]
教      s1[3]
育      ....
最
...
'''

s1 = '老男孩教育最好的讲师：太白'
print(len(s1))   #13

#while循环代码(利用while循环打印可迭代对象的每个元素)
s1 = '老男孩教育最好的讲师：太白'
index = 0
while index < len(s1):   # len（） :获取可迭代对象的元素总个数，是内置函数。不是字符串专用的
     print(s1[index])
     index += 1


# for 循环

'''
有限循环
for 变量 in iterable:
    pass
'''

#for循环代码
s1 = '老男孩教育最好的讲师：太白'
for i in s1:
     print(i)

        #
for i in s1:
    print(i)
    if i == '好':
        break

# break continue
# for else: while else:用法一样。