day---04 基本数据类型（上）

切片理解方法：    https://www.jianshu.com/p/15715d6f4dad      NB

======================================基本使用======================================
1、用途
2、定义方式
3、常用操作+内置的方法
======================================该类型总结====================================
存一个值or存多个值

有序or无序　　

　　有序：但凡有索引的数据都是有序的

　　无序：那一定是不能索引取值了呗
可变or不可变 

　　可变类型：值改变的情况下，id不变，说明改的是原值，则为可变

　　不可变类型：　值改变的情况下，id一定变了，则是不可变

　　　　总结是一句话：因为值都发生了变化，看id，id不变就可变类型，id变就不可变类型

　　　　　　x = 10

　　　　　　print(id(x))

　　　　　　y = 11

　　　　　　print(id(y))           

　　　　　　　　看x,y   id的变化    判断他们的类型

数字类型

整型（int）

======================================基本使用======================================
1、用途：存年龄，QQ，电话
2、定义方式：

age = '18'  # age = int(18)

　　

print(int('ahjsdh'))
print(int(1.155165))
整型的转换只能转换纯数字的整数字符串，这就说明了小数点都不能带，否则报错。所以上面两种结果都是报错

进制之间的转换

　　非十进制转换十进制

　　1 二进制转十进制  # 二进制数字只包含0，1

　　　　二进制10转换为十进制

　　　　　　转换算法          1*(2**1) + 0*(2**0)  # 2 

　　2 八进制转十进制  # 八进制数字只包含0-7 

　　　　八进制235转换为十进制

　　　　　　转换算法          2*(8**2) + 3*(8**1) +5*(8**0)  # 157

　　3 十六进制转十进制  # 十六进制包含0-9 A-F      A-F类似10-15

　　　　十六进制217转换为十进制

　　　　　　转化算法　　　2*(16**2) + 1*(16**1) +7*(16**0)  # 535

　　十进制转换非十进制

　　　　十进制转换为二进制

　　　　　　print(bin(12))  # 0b1100  0b表示后面的数字是二进制数

　   　　十进制转换为八进制

　　　　　　print(oct(12))  # 0o14  0o表示后面的数字是八进制数
　　　　十进制转换为十六进制
　　　　　　

　　　　　　print(hex(12))  # 0xc  0x表示后面的数字是十六进制数

直接将其他进制数转为十进制数
　　print(int('1100',2))

　　print(int('14',8))

　　print(int('c',16))
　　　　最后的数字就是代表之前是几进制的   这样之后直接转换成十进制

3、常用操作+内置的方法　　
======================================该类型总结====================================
存一个值or存多个值 

　　存一个值
有序or无序

　　有序：但凡有索引的数据都是有序的
可变or不可变  

浮点型：float

　　======================================基本使用======================================
1、用途：存薪资，身高，体重等一系列带小数点的数字
2、定义方式：salary = 1.1  # salary = float(1.1) 

字符串 str

字符串 str ： 字符串内所有都算一个字符包括空格

s = 'hello baby'  # str('hello baby')
s1 = str([1,2,3,4])
print(type(s1))
s2 = str({'name':'jason','password':123})
print(type(s2))
字符串是一对引号之内的看做一整个数据   但是里面的字符是可以按照索引，字符串可以将列表和字典都直接转为字符串

======================================基本使用======================================
1、用途：用来记录具有描述性的数据，个人资料，其实什么都能记
2、定义方式：三种方式：　　

　　　　　　　　单引号 　　　'内容'

　　　　　　　　双引号 　　　‘"内容"

　　　　　　　　三引号 　　　"""内容"""     # 三引号之前有变量名就是字符串，没有才是注释

3、常用操作+内置的方法

======================================该类型总结====================================
存一个值or存多个值

　　存一个值

有序or无序　　

　　有序

可变or不可变 

　　不可变类型

　　常用内置方法

1 按照索引取值(正取向+反取向)： 只能取值

a = "hello nice to meet you!"
print(a[0])  # h

2 切片(顾头不顾尾，步长)
从一个大的字符串中，取出自己想要的一部分   [头:尾:步长] 这里都是按照索引   步长(自己设定)可以不写默认为1格
正向的      索引从0开始

a = "hello nice to meet you!"
print(a[5:11])  #  nice      n前有一个空格  步长没写默认为1
print(a[4:8:1])  # o ni      步长为1的
print(a[4:8:2])  # on        步长为2的
负向的
print(a[-1])  # !  这个是取值    从右往左第一个是！      反向的所有是从-1开始
print(a[0:5:-2])  # 空白的  因为切片取值默认是从左向右的这个起点是0   这就例如让你面向前走但是步子向后迈，NB反正我不行
print(a[9:0:-1])  # ecin olle  因为切片取值默认是从左向右的这个起点是9
print(a[-2:-10:-2])  # uyte    这就是反着走了，只不过是面向前方

3 长度 len :字符串统计的是个数

a = "hello nice to meet you!"
print(len(s))  # 15   长度是15

4 成员运算 in 和 not in       用来判断一个某个或某段字符在不在你的大字符串内

a = "hello nice to meet you!"
print('egon'in a )  # False
print('hello'in a)  # True
print('egon' not in a)  # True
print('meet' not in a)  # False

5 去掉字符串内左右两边的字符包括空格    stirp，  中间的不行  默认去除首尾的

a = '!@#$% hello ^&*()'
print(a.strip(' !@#$%'))  # hello ^&*()
print(a.strip('!@#$%^&*() '))  # hello
可以用于登陆系统手抖的小哥哥们
username = input('please your username>>>:').strip('!@#$%^&*() _+|-=*  ')
print(username)
lstrip,rstrip
name = '!@#!@# james !@#!@#'
print(name.lstrip(' !@#'))  # james !@#!@#  去除左边的想取消的符号
print(name.rstrip(' !@#'))  # !@#!@# james  去除右边的想取消的符号

6 split 可以将字符串内任意字符作为切分目标 切分结果是列表   可以按照索引取值  默认从左往右切分

msg = '你说的对 hello,xiao|||gui,'
print(msg.split('你说的对'))  # ['', ' hello,xiao|||gui,']
print(msg.split('||'))  # ['你说的对 hello,xiao', '|gui,']

rsplit  切分顺序其实是从左往右的 但是有了步长以后 就是将那一个符合的切分掉 再从左往右打印出来
所以如果不写split 和 rsplit的话效果一样的

msg = 'hello word!!!'
print(msg.rsplit('!',1))  # ['hello word!!', '']

7 循环    就是用for循环取值

msg = 'hello,world!'
for i in msg:
    print(i)

掌握的

1 stirp，lstrip，rstrip

msg = '#####james#####'
print(msg.strip('#'))  # james   去除左右两边的字符 可以是任意字符但是如果被包裹在没有被清除的字符中间就不会去除了
print(msg.lstrip('#'))  # james#####   去除左右两边的字符 可以是任意字符但是如果被包裹在没有被清除的字符中间就不会去除了
print(msg.rstrip('#'))  # #####james   去除左右两边的字符 可以是任意字符但是如果被包裹在没有被清除的字符中间就不会去除了

2 lower，upper

name = 'Kobe Bryant'
print(name.lower())  # kobe bryant    全部转换成小写
print(name.upper())  # KOBE BRYANT    全部转换成大写

3 startswith，endswith

name = 'Kobe Bryant'
print(name.startswith('Ko'))  # True       是否以什么开头
print(name.startswith('Koc'))  # False     是否以什么结尾
print(name.endswith('ant'))  # True
print(name.endswith('asjkd'))  # False

4 format的三种用法 也是格式化输出的一种方式  python推荐使用的格式化输出

第一种 按照位置传，和%s原理一样   但是只能按位置填写，写错了就成下面的结果 ！！！
info = '我是{}，我今年{}岁'.format('许兆龙',22)  # 我是许兆龙，我今
info1 = '我是{}，我今年{}岁'.format(22,'许兆龙')  # 我是22，我今年许兆龙岁
print(info)
print(info1)

第二种，按照索引取值
info = '我是{0},你们都是{1},{2}'.format('swb','弟弟','哈哈哈')
print(info)

第三种，按照关键字位置传参
name = 'james'
msg = '总冠军'
info = 'my name is {name1},湖人{msg1}'.format(name1 = name,msg1 = msg)  # my name is james,湖人总冠军
info1 = 'my name is {name},湖人{msg}'.format(name = 'kobe',msg = '总冠军')  # my name is kobe,湖人总冠军
print(info)
print(info1)

 5 切分 split rsplit    上面查找 6

 6 join

msg = 'james|66666|总冠军'
res_list = (msg.split('|'))
print(res_list)  # ['james', '66666', '总冠军']
res = '$'.join(res_list)
print(res)  # james$66666$总冠军

lis = ['1','a','b']
res1 = "=".join(lis)
print(res1)  # 1=a=b

不同种类型的数据类型不能添加
lis = [1,'a','b']
res1 = "=".join(lis)
print(res1)  # 报错，因为1不是字符串类型和'a'，'b'不一样

7 replace 更改索引位置的字符

msg = 'what do you color see see'
res = msg.replace(' ','NB')
res1 = msg.replace(' ','NB',1)  # 只更改索引的字符
print(msg)
print(res)  # whatNBdoNByouNBcolorNBseeNBsee
print(res1)  # whatNBdo you color see see

8 isdigit  判断输入是否是纯数字

while True:
    num = input('输入的是不是纯数字:>>>')
    print(num.isdigit())

9 find rfind index rindex count

msg = 'kevin is dsb o and kevin is sb'
print(msg.find('dsb'))  # 9   返回的是d字符所在的索引值
print(msg.rfind('dsds'))  # -1 找不到的时候不报错  返回-1
print(msg.find('o',1,15))  # 13   (查找目标字符，起始位置，终止位置)
print(msg.index('i'))  # 3 找到的第一个目标字符的索引值
print(msg.index('i',11,25))  # 22 查找范围内的目标字符，但是所以值是相对于所有字符的索引
print(msg.count('i'))  # 4 目标字符出现次数

10 center ljust rjust zfill

s = 'jason'
print(s.center(11,'#'))  # ###jason###     原有字符串居中 左右用输入补齐输入的元素个数
print(s.ljust(11,'&'))  # jason&&&&&&      原有字符串左对齐 右边同上
print(s.rjust(11,'*'))  # ******jason      原有字符串右对齐 左边同上
print(s.zfill(11))  # 000000jason   原有字符串右对齐  左边用0补齐   只能用0

11 expandtabs

s = 'a	abc'          	 空格
print(s.expandtabs(20))  	位置用空格填充  数量是expandtans后面的参数

12 captalize swapcase title

s = 'heLLO WOrlD Sh11'
print(s.capitalize())  # Hello world sh11     首字母大写
print(s.swapcase())  # HEllo woRLd sH11     大小写转换
print(s.title())  # Hello World Sh11       每个单词首字母大写

13 is数字

num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='壹' #中文数字
num4='Ⅳ' #罗马数字

print(num2.isnumeric())  # True
print(num3.isnumeric())  # True
print(num4.isnumeric())  # True
isnumerica 只要是表示数字都能识别出来

print(num2.isdecimal())  # True
print(num3.isdecimal())  # Flase
print(num4.isdecimal())  # False
isdecimal  只能是被阿拉伯数字

print(num1.isdigit())  # True
print(num2.isdigit())  # True
print(num3.isdigit())  # False
print(num4.isdigit())  # False
isdigit 通常情况下isdigit就能满足需求

列表 list

列表 list

======================================基本使用======================================
1、用途 ：记录一些同类型的数据  女朋友们
2、定义方式：在[]内记录数据，并且没有数据之间用逗号隔开
3、常用操作+内置的方法
======================================该类型总结====================================
存一个值or存多个值

　　存多个值

 有序or无序　　

　　有序

可变or不可变 

　　可变

常用操作

1 按照索引取值 [正向存取+反向存取]：可以存也可以取     顾头不顾尾

l = [1,2,3,4]
print(id(l))  # 38873032
print(l[3])  # 4
print(l[0:3:1])  # [1, 2, 3]     [其实位置，终止位置，步长]  从起始位置到终止位置按照每一步取一个值
print(l[0::])  # [1, 2, 3, 4]    不写终止位置   默认从起始到结束   默认步长1
print(l[5::-1])  # [4, 3, 2, 1]   反向取值
l[0] = 11
print(id(l))  # 38873032
print(l)  # [11, 2, 3, 4]   按照索引将指定位置的元素改变

2 切片(顾头不顾尾，步长)

末尾添加
l = [1,2,3,4,5]
l1 = [6,7,8,9]
l.append(6)
print(l)  # [1, 2, 3, 4, 5, 6]    append   直接末尾添加6

insert 任意位置添加
l = [1,2,3,4,5]
l1 = [6,7,8,9]
l.insert(2,55)
print(l)  # [1, 2, 55, 3, 4, 5]    insert  固定位置添加元素

extend 添加容器类型数据
l = [1,2,3,4,5]
l1 = [6,7,8,9]
l.append(l1)
print(l)  # [1, 2, 3, 4, 5, [6, 7, 8, 9]]     整个列表添加在末尾
l.insert(-1,l1)
print(l)  # [1, 2, 3, 4, [6, 7, 8, 9], 5]     整个列表按照索引添加

l = [1,2,3,4,5]
l1 = [6,7,8,9]
l.extend(l1)
print(l)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]     只添加列表内元素  内部原理for循环l1一个个追加到列表的尾部

3 长度 len

l = [1,2,3,4]
print(len(l))  # 4

4 成员运算 in   和   nor in

l = [1,2,6,4,5,7,8]
print(222 in l)  # False
print(2222 not in l)  # True

5 添加元素

    append
    insert
    extend

6 删除

l = ['hahaha','ayshdjhaskjdh']
print(l)  # ['hahaha','ayshdjhaskjdh']
del l[0]  # del 使用所有的删除操作
print(l)  # ['ayshdjhaskjdh']

l = [1,2,6,4,5,7,8]
res1 = l.pop()  # 尾部弹出
res2 = l.pop()
res3 = l.pop()
print(res1,res2,res3)      # 后进 先出原理

l = [1,2,6,4,5,7,8]
res1 = l.pop(0)  # 可以指定索引 按照索引弹出元素   这里的索引yong()
print(res1)

l = [1,2,6,4,5,7,8]
res = l.remove(8)  # 指定要删除的元素的值
print(l)
print(res)

s = 'haha'
print(s)
del s
print(s)  # 是不是报错了    当然  因为他已经被del  了   所以打印的字符串没有所以   name 's' is not defined  没有找到

7 循环

l = [1,2,6,4,5,7,8]
for i in l:
    print(i)

8 列表的常用方法

l = [1,2,3,4,5,6]
res = l.count(8)
print(res)  # 查找元素个数，有的有几个就输出几

clean
print(l.clear()) # None 删除列表

reverse
l = [1,2,45,6,875,6]
print(id(l))
l.reverse()
print(id(l))
print(l)  # [6, 875, 6, 45, 2, 1]  # 将列表反转


l.sort()
print(l)  # 默认按照升序
l.sort(reverse=True)
print(l)  # [6, 5, 4, 3, 3, 2, 1]   reverse = True时   为降序

不是只有这些 ，还有之前字符串的      在列表里面  点  出来的用法是一样的

队列     先进先出
先进
l = []
l.append(1)
l.append(2)
l.append(3)
先出
print(l.pop(0))  # 1
print(l.pop(0))  # 2
print(l.pop(0))  # 3
#
#
#
堆栈     先进后出
先进
l = []
l.append(1)
l.append(2)
l.append(3)
l.append(4)
后出
print(l.pop())  # 4
print(l.pop())  # 3
print(l.pop())  # 2
print(l.pop())  # 1