今日学习内容

数据类型的内置方法简介

1.内置方法可以简单理解成是每个数据类型自带的功能（每个人的不同特长）

2.结构：
   名字＋括号--->调用某个功能。
   eg：print(...)调用打印功能
       int(...)调用创建整型数据功能
       float(...)调用创建浮点型数据的功能
    
    使用数据类型的内置方法统一采用句点符。
    数据类型.方法名()
        eg:
            'xz'.字符串具备的方法()            
             name = 'xz'
             name.字符串具备的方法()
3.如何快速查看某个数据类型的内置方法，借助于编译器自动提示。
4.我们在学习内置方法过程中还会穿插一些其他用法。
    print(int(True))  # 1
    print(int(False))  # 0

整型相关方法

1.关键字  int()
2.若 age=10 ，  本质 age = int(10)
3.整型就是整数，主要用于计算，没有内置函数。
4.类型转换：
      int(待转的数据)
  4.1 int可以将由纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错。
      >>> s = '123'
      >>> res = int(s)
      >>> res,type(res)
     (123, )
  4.2 如果字符串出现了字母，还是小数点等，都会报错的。
      >>> print(type(int('123a321')))
Traceback (most recent call last):
  File "", line 1, in 
ValueError: invalid literal for int() with base 10: '123a321'
      >>> print(type(int('123.33')))
 Traceback (most recent call last):
   File "", line 1, in 
 ValueError: invalid literal for int() with base 10: '123.33'
            

进制转换

1.进制种类有：二进制 八进制 十进制 十六进制
2.浮点型就是小数，主要用于计算，没有内置函数。
3.十进制转其他进制：

  2.1 print(bin(100))  
      bin() 将十进制转二进制  0b1100100  0b是二进制数的标识

  2.2 print(oct(100))  
      oct() 将十进制转八进制  0o144      0o是八进制数的标识
    
  2.3 print(hex(100)) 
      hex() 将十进制转十六进制  0x64     0x是十六进制数的标识

4.如果数字前面没有任何标识，默认就是十进制。

5.其他进制转十进制
    print(int(0b1100100))   # 100
    print(int(0o144))       # 100
    print(int(0x64))        # 100
  5.1python直接将其他进制数以十进制来输出。
  5.2人为指定进制数
    print(int('0b1100100', 2))  # 100
    print(int('0o144', 8))  # 100
    print(int('0x64', 16))  # 100
    
6.整型会自动把布尔值转换成 1 或 0

浮点数相关方法

1.关键字 float()

  1.1 >>> s = '12.3'
      >>> res=float(s)
      >>> res,type(res)
    (12.3, )
  1.2 
     print(float('123'))  # 123.0
     整型转换成浮点型则后面是补齐一个小数点后一位
     print(type(float('123')))  # float
     
     print(float('123a123'))
     有字母和数字就不能转换成浮点型，会报错。
     print(float('123.12')) 
     可以识别一个小数点，但不能识别多个小数点，不然会报错。
     print(float('123.123.1.2.2.2.2.2.2'))  

2.浮点型会自动把转换成 1.0 或 0.0
    print(float(True))  # 1.0
    print(float(False))  # 0.0
    
   

补充说明

eg:
a = 23.00
b = 1.2
c = a * b  
print(c)  # 27.599999999999998
python对数字不敏感 很容易出错,但是基于python开发的模块很厉害。

字符串相关方法

1.关键字 str()
2.关系转换
类型转换:兼容所有数据值
    print(str(123), type(str(123))) #123 
    print(str(123.11), type(str(123.11))) #123.11 
    print(str([1, 2, 3, 4]), type(str([1, 2, 3, 4])))
    #[1, 2, 3, 4] 
    print(str({'name': 'jason'}), type(str({'name': 'jason'})))
    #{'name': 'jason'} 
    print(str(True), type(str(True)))
    #True 
    print(str((1, 2, 3, 4)), type(str((1, 2, 3, 4))))
    #(1, 2, 3, 4) 
    print(str({1, 2, 3, 4}), type(str({1, 2, 3, 4}))) 
    #{1, 2, 3, 4} 
    无论数据类型是什么，都会转换成字符串类型。

    
3.操作的方法
怎么访问字符串里的数值？
      字符串[开始索引：结束索引：步长]  
    注意:
    切取字符串为开始索引到结束索引-1内的字符串
    步长不指定时步长为1 字符串[开始索引:结束索引]
    
1.按索引取值(正向取/反向取)：(左包含右不包含)
    >>> str1 = 'hello python!'
    1.1 正向取(从左往右)
        >>> str1[6]
        p
    1.2反向取(负号表示从右往左)
        >>> str1[-4]
        h
    1.3对于str来说，只能按照索引取值，不能改，报错TypeError。
        >>> str1[0]='H' 
   
2.切片:取出多个字符,支持负数，切片的顺序默认从左往右最后一个参数是负号则取值方向从右往左。
    2.1顾头不顾尾：取出索引为0到8的所有字符
        >>> str1[0:9]  
        hello pyt
  
    2.2 反向切片（ -1表示从右往左依次取值）
        >>> str1[::-1]  
        !nohtyp olleh
    
3.间隔/方向
    3.1 步长：0:9:2,第三个参数2代表步长，会从0开始，每次累加一个2，会取出索引0、2、4、6、8的字符。
       中间间隔一个字符取值。默认1可以不用写。
        >>> str1[0:9:2]  
        hlopt 
    3.2 取出全部
        >>> str1[:]
        hello python!

4.统计字符串中字符的个数 len
      print(len(s1))  #13
   注意：空格也算字符。 

5.移除字符串首尾指导的字符  strip   （注意中间的空号不能被移除）
  name = '  xz  '
      print(len(name))  # 6
      print(name.strip(), len(name.strip()))  # xz 2
  注意：字符串调用内置方法，不是改变原数据，而是产生了新的数据值，但这些数据值都是一次性的，在没有变量名绑定的时候，是不能一直使用。
  res = name.strip()
      print(name,len(name)) #  xz   6
      print(res,len(res)) #xz 2
  desc1 = '$$xz$$'
      单独的strip的含义是移除所有的 $
      print(des1.strip('$')) #xz
      前加l意思是从左边看，移除左边的$
      前加r意思是从右边看，移除右边的$
      print(des1.lstrip('$') #xz$$
      print(des1.rstrip('$'))) #$$xz
    eg:
      username = input('username>>>:')
      username = username.strip()  
   先获取用户输入 再立刻移除首尾空格 最后绑定给变量名username 
      username = input('username>>>:').strip()            
   作用是自动过滤用户输入多个空格，防止用户这样报错。上面是完整的代码，下面是第二个代码简写。    
      if username == 'xz':  
        print('登录成功')
      else:
        print('你不是xz!')
  

6.按照指定的字符切割字符串 split
       info = 'xz|123|read'
    当字符串中出现了连续的特征符号，应该考虑使用切割操作。
       res = info.split('|')
    切割后的结果是一个列表。
       print(res, type(res)) 
      #['xz', '123', 'read'] 
       name, pwd, hobby = info.split('|')  
      # name, pwd, hobby = ['xz', '123', 'read']
    相当于解压赋值，右边的字符串切割成列表的各个数据值。
    然后再分别赋值给左边的变量名。
        print(info.split('|', maxsplit=1)) 
       # ['xz', '123|read']
    从左往右切割，且只能切一次。
         print(info.split('|', maxsplit=1)) 
       # ['xz|123','read']
    从右往左切割，且只能切一次。
 
7.字符串大小写相关 lower upper
    s2 = 'HeLLo python 666 你好吗'
    print(s2.lower())  #全部转换成小写字母，但数字和中文都不改变
    print(s2.upper())  #全部转换成大写字母，数字和中文同上
    print(s2.islower())  #is本身就是判断布尔值的标识，结果是布尔值。判断是否为全为小写字母
    print(s2.isupper())  #判断是否全为大写字母，结果为布尔值。
    print('aaa'.islower())  #Ture
    print('AAA'.isupper())  #True  
   
eg:这种方法可以转换用户输入的验证码的大小写，且不影响登录的效果。
    
    方式一：

code = 'Xzeb6'
print('这是网页给你返回的随机验证码:%s' % code)
confirm_code = input('请输入验证码>>>:')
code_upper = code.upper()  # 将网页返回的验证码转大写
confirm_code_upper = confirm_code.upper()  # 将用户填写的验证码转大写
if confirm_code_upper() == code_upper():  # 统一转大写 再做比对
    print('验证码正确')
else:
    print('验证码错误')
    
    方式二：
code = 'Xzeb6'
print('这是网页给你返回的随机验证码:%s' % code)
confirm_code = input('请输入验证码>>>:')
if confirm_code.lower() == code.lower():  # 统一转小写 再做比对
    print('验证码正确')
else:
    print('验证码错误')

8.字符串的格式化输出  {}   format
     方式1: 等价于%s占位 没有什么优势，这里是用{}占位符。xxx.format
        res1 = 'my name is {} my age is {}'
        print(res1.format('xzn', 18))
        #my name is xzn my age is 18
        
     方式2: 支持索引取值 并且支持重复使用。xxx.format
        res2 = 'my name is {0} my age is {1} {0} {1} {1} {1}'
        print(res2.format('xz', 18))
        #my name is xz my age is 18 xz 18 18 18
     方式3: 支持关键字取值(按k取值) 并且支持重复使用。xxx.format
        res3 = '{name} {name} {age} my name is {name} my age is {age}'
        print(res3.format(name='xz', age=18))
        #xz xz 18 my name is xz my age is 18
     方式4: f''
        #定义变量，简写f后面用变量名表示。
        name = 'xz'
        age = 18
        print(f'my name is {name} my age is {age} {name} {age}')
        #my name is xz my age is 18 xz 18

9.统计字符串中指定字符出现的次数   count
res = 'sqwhasjdjahdjwqhdjkasdhdadadad'
print(res.count('j'))#4
print(res.count('ad'))#3

10.判断字符串的开头或者结尾  startswith/endswith
res = 'xz say ha ha hei'
#判断开头的字符，是为True，否为False
print(res.startswith('xz'))
print(res.startswith('x'))
print(res.startswith('b'))
#最后结尾的字符判断，结果为布尔值
print(res.endswith('hei'))
print(res.endswith('h'))

11.字符串的替换 replace
res = 'xz xz xz  nihao '
print(res.replace('xz', 'wyb'))  # 从左往右全部替换
print(res.replace('xz', 'wyb', 1))  # 从左往右替换指定个数为1
#wyb wyb wyb  nihao 
#wyb xz xz  nihao 

12.字符串的拼接 join
    12.1
       	res1 = 'hello'
        res2 = 'world'
         # 字符串支持加号拼接
        print(res1 + res2) 
        # 字符串支持乘号重复10次输出
        print(res1 * 10)  
    12.2 支持用符号拼接
        data_list = ["Kevin","age","address"]
        v1 = "_".join(data_list) 
        print(v1)  # Kevin_age_address
        
    12.3 print('$'.join(['xz', 'say', 666]))  # 列表中的数据都必须是字符串类型，不然保错！！！
    

13.判断字符串中是否是纯数字 isdigit
print('123'.isdigit())  # True
print('123a'.isdigit())  # False
print(''.isdigit())  # False 
只能纯数字才能被识别成True，不然为False

14.查找某个字符对应的索引值  index
res = 'hello world xz'
print(res.index('d'))  # 10
print(res.find('d'))  # 10
index查找索引 ，若没有元素，则报错
find查找索引，若没有元素，则不会报错，但是结构为-1，也是就False
print(res.index('d', 0, 5))，在第0索引值和第4个索引值范围内查找该字符。
print(res.find('d', 0, 5))#-1

15.正文相关操作
    res = 'my name is jason'
    print(res.title())  # My Name Is Jason
    如果字符串是标题化的，则见(title())则返回为True，不然返回为False。
    内容第一个字母为大写
    print(res.capitalize())  # My name is jason
    

列表的相关方法

1.关键字 list
2.类型转换

print(type(list(123)))
print(type(list(123.22)))
print(type(list('123243jasdsad')), list('123243jasdsad'))
# ['1', '2', '3', '2', '4', '3', 'j', 'a', 's', 'd', 's', 'a', 'd']
print(type(list({'name':"jason",'pwd':123})),list({'name':"jason",'pwd':123}))
# ['name', 'pwd']

列表只能将字典和字符串转化成功，整数和浮点数不能。
所以能够被for循环的数据类型都可以转换成列表

l1 = ['jason', 'kevin', 'oscar', 'tony']
   2.1索引取值：
     	print(l1[0])#jason
        print(l1[-1])#tony
        负数为从右向左取值，-1位最右边第一个
   2.22.切片操作
        print(l1[0:3])#['jason', 'kevin', 'oscar']
        print(l1[:])#['jason', 'kevin', 'oscar', 'tony']
        print(l1[-4:-1])#['jason', 'kevin', 'oscar']
        从右到左包含-1，-4
   2.3间隔/方向
        print(l1[::2])#['jason', 'oscar']
   2.4统计列表中数据值的个数
        print(len(l1))#4

2.内置函数
  1.count()：用来统计成员在列表中出现的次数。
  2.index():返回改元素的索引值。
              >>> list = [123,12,13]
              >>> list *= 3
              >>> list
              [123, 12, 13, 123, 12, 13, 123, 12, 13]
              >>> list.index(123)
              0
              >>> list.index(123,2,5)
              3
通过这个列子我们就知道，当列表包含多个成员的时候，返回的是该成员的第一次出现的位置，同时，我们还可以对index()设置参数，查询成员在特定位置范围内出现的索引值，列如index(menber,m,n),表示member在第m-1个到第n-1个位置第一次出现的索引值。
   3.reverse():就是将列表中的元素前后颠倒。
   4.sort():将元素从小到大排序。
            如果想让无序列表从大到小排序，那么可以先用sort() 的方法，再用reverse()方法。
            当然我们可以用简便的方法--
            >>> list
              [123, 12, 13, 123, 12, 13, 123, 12, 13]
            >>> list.sort(reverse = True)
            >>> list
            [123, 123, 123, 13, 13, 13, 12, 12, 12]
    5.append():向列表中添加成员
            >>> list.append(2)
            >>> list
            [123, 123, 123, 13, 13, 13, 12, 12, 12, 2]
            >>> list.append('8')#可以添加字符类型的元素。
            >>> list
            [123, 123, 123, 13, 13, 13, 12, 12, 12, 2, '8']
            注意：一次只能添加一个成员，并且只能添加在列表的末尾。如果想继续在列表中添加成员，可以通过append()方法，而不能采用extend()因为这会将列表里面的每个成员拆分成单独的成员添加到列表中。   
    6.exend():该方法也是向列表中添加成员，并且也是参数，但可以列表扩展列表（意思是exend后面是列表时，就会多加的列表里的成员到要添加的列表的后面）如果exend后面跟字符串，则就会一个个字符拆开后依次再加入到列表后面。如果想让字符串完整的加入列表，则需要用列表的形式来添加。
    7.insert():在特定位置添加成员。两个参数，insert（m,member）,在索引为m（也就是第m+1的位置进行添加），注意:因为是两个参数，索引多加一个参数就会造成错误。
    8.remove():从列表中删除指定成员。remove（要删除的成员）
               注意：当列表中有多个重复成员时，一次只能删第一个。
    9.del :用索引进行删除
           del list [2] 删除列表索引为2 的数据值。
    10.pop{}:将指定位置的元素取出来，并删除，也就是说有返回值。
            >>> list1 = [123, 456, 789]
            >>> list1
            [123, 456, 789]
            >>> b = list1.pop(1)
            >>> b
            456
            >>> list1
            [123, 789]
       pop{}方法将指定位置对策成员提取出来，返回并且删除了该成员。当pop()后面不加参数的时候，返回的是最后一个。

作业

1.基于字符串充当数据库完成用户登录(基础练习)
data_source = 'jason|123' # 一个用户数据
获取用户用户名和密码 将上述数据拆分校验用户信息是否正确

# #模拟一个数据库，将数据放在里面
data_source = 'jason|123'
# #先用split切割功能，将字符串里的数据切割成一个列表，最小单位为单个数据值，再解压赋值给左边的变量名
name, pwd = data_source.split('|')
# #这里我设置了一个操作三次输入密码错误将推出程序。
for i in range(3):
    #定义一个用户输入用户名，加个去除空号的作用
    username = input('输入用户名:').strip()
    # 定义一个用户输入密码
    password = input('输入密码：').strip()
    if username == name and password == pwd:
        print('登录成功！')
        #这里设置了一个登录成功就退出程序
        break
    else:
        print('你的用户名或者密码错误！')

2.基于列表充当数据库完成用户登录(拔高练习) # 多个用户数据
data_source = ['jason|123', 'kevin|321','oscar|222']

data_source = ['jason|123', 'kevin|321', 'oscar|222']

#这里我设置无限次数，是因为我想多次试验用户输入的用户名和密码是不是匹配，输入是不是正确。
while True:
    #定义一个用户输入用户名加个去除空号的作用，防止用户在输入时多打出空号而出错。
    username = input('输入用户名:').strip()
    # 定义一个用户输入密码
    password = input('输入密码：').strip()
    #这里是列表，所以我可以用for循环取出每个数据值
    for i in range(3):
        #取出的数据值再除去|，再用解压赋值给左侧变量名。
        name, pwd = data_source[i].split('|')
        #判断用户名和密码是否正确，正确就退出循环，不正确将继续接着在列表中取下一个值。
        if username == name and password == pwd:
            print('登录成功！')
            break
    else:
        print('你的用户名或者密码错误！')


另一种方法：
#数据库存放数据
data_source = ['jason|123', 'kevin|321', 'oscar|222']
#设置无限循环，可以无限试用密码和用户名是否匹配。
while True:
    #输入用户名和密码
    username = input('输入用户名：').strip()
    password = input('输入密码：').strip()
    #这里是列表，所以我可以用for循环取出每个数据值
    for i in range(3):
        #定义一个变量来绑定username和password和起来再加上|来和数据库里做比较，相同则输入正确，错误就失败。
        data_user = (username + '|' + password).strip()
        if data_user == data_source[i]:
            print('登录成功')
            break
    else:
        print('登录失败')