数字类型、字符串和列表

数字类型

1.整型(int)

　　用途：存QQ号，手机号等纯数字

定义方式：

age = 18　　# age =  int(18)
int('adx')和int('1.1')存在错误　　#int只能转纯数字的字符串，有小数点的转不了

2.整型的进制转换

1).其他进制转十进制

二进制转十进制    0,1
10     #1*(2**1)+0*(2**0)
八进制转十进制    0-7
236    #2*(8**2)+3*(8**1)+6*(8**0)
十六进制转十进制    #0-7，A-F
21    #2*(16**1)+1*(16**0)

print(int('1100',2))　　#int可以存第二个参数，用来表示第一个参数是什么进制
print(int('14',8))
print(int('c',16))

2).十进制转其他进制

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

十进制转八进制
print(oct(12))   #    0c表示后面的数字是八进制 
>>>:0o14

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

3).可变类型和不可变类型

　　可变类型：值改变的情况下，id不发生变化，说明你改的是原值。

　　不可变类型：值发生改变的同时，id也发生了变化，相当于重新创立了一个变量空间。

3.浮点型(float)

　　作用：薪资，身高，体重，一般作用于小数。

定义方式：
rest = float('1.11')
print(rest)　　　　#输出：1.11　　　

字符串(string)

1.作用

　　用来记录人的名字，家庭住址，性别等描述性质的状态

2.定义

　　用单引号、双引号、多引号，都可以定义字符串，本质上是没有区别的。但是有两点需要注意：

#1、需要考虑引号嵌套的配对问题
msg = "My name is Tony , I'm 18 years old!"    #内层有单引号，外层就需要用双引号
#2、多引号可以写多行字符串
msg = '''
          可作为注释使用。
      '''

 3.常用操作

1).按索引取值（正向取+反向取） ：只能取

s = 'hello world'
print(s[0])　　#   输出h  

2).切片 (顾头不顾尾，步长)；从一个大的字符串中截取一段新的小字符串

s = 'hello world'
print(s[0:5])    #hello   步长不写默认为是1
print(s[2: :])    #中间部分不写，默认为len(s)
print(s[0:10:2])    #步长表示隔几个取一个

了解复数取值
print(s[-1])    #输出为 d
print(s[0:5:-2])    #切片取值默认从左往右的
print(s[5:0:-1])    #切片取值默认从左往右的
print(s[-1:-10:-1])

3).长度len()：统计的是字符串中字符的个数

s = ('s', 'df', 'ff', '  ', 'fd', 'erf')
print(len(s))                 # 统计字符的个数
>>>:6

4).成员运算in和not in，判断一个子字符串是否存在于一个大的字符串中。

print('hello'in 'hello world')    # True
print('h' not in 'hello world')    # False
print('happy' in 'hello world')    # False

5).切分spilt；针对按照某种分隔符组织的字符串，可以用split将其切分成列表，进而进行取值

data = 'hello|123| hp'
print(data.split('|'))    # ['hello', '123', ' hp']
强调:split切分出来的数据类型是一个列表
print(data.split('o'))    # 切割的顺序其实从左往右的
print(data.split('o',1))  # 切割的顺序其实从左往右的
print(data.rsplit('o',1))  # 切割的顺序其实从左往右的
如果不指定那么split和rsplit效果是一样

6) 移除a.strip()，移除字符串首尾指定的字符(默认移除空格)

a = '  life is short  '
print(a.strip())  # 括号内不指定字符，默认移除首尾空格
>>>:life is short

b = '$$life is short$$'
print(b.strip('$'))  # 括号内指定字符，移除首尾指定的字符
>>>:life is short

7).for循环

for  变量名  in   容器类型(字符串)   # 依次取出字符串中的每一个字符

4.较常用操作

1).strip, lstrip, rstrip

app = '**hehe***'
print(app.strip('*'))    # 移除左右两边的指定字符
>>>:'hehe'
print(app.lstrip('*'))    # 移除左边的指定字符
>>>:'hehe***'
print(app.rstrip('*'))    # 移除右边的指定字符
>>>:'**hehe'

2).lower(), upper()

s = 'hello wORLD '
print(s.lower())   # 全部转换成了小写
>>>:hello world
print(s.upper())  # 全部转换成了大写
>>>:HELLO WORLD 

3).startswith, endswiths 

print(s.startswith('h'))  #true#用于检查字符串是否是以指定子字符串开头
>>>:True
print(s.endswith('d'))    #true#用于检查字符串是否是以指定子字符串结束
>>>:Flase

4).format的三种用法(python推荐使用.format做格式化输出)

#第一种  按位置占位   跟%s原理一致
s = 'my name is {} my age is {}'.format('li',18)
print(s)    # my name is li my age is 18


#第二种  按索引占位
s = 'my {1} name is {0} my age is {0}'.format('li',18)
print(s)    # my 18 name is li my age is li


#第三种  指名道姓占位（关键字传参）
s = 'my {name} name is {age} my {name} age is {age}'.format(name='li',age=18)
print(s)    # my li name is 18 my li age is 18

5).join   # 将容器类型中的多个元素通过指定字符拼接成一个字符串

# 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
print('%'.join('hello'))     # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接
>>> :'h%e%l%l%o'
print('|'.join(['li','18','read']))     # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接
>>> :li|18|read'

6) spilt, rspilt    # 切分

# split会按照从左到右的顺序对字符串进行切分，可以指定切割次数
str5 = 'a/b/c/d.txt'
print(str5.split('/', 2))    # rsplit刚好与split相反，从右往左切割，可以指定切割次数
>>>:['a', 'b', 'c/d.txt']
print(str5.rsplit('/', 2))
>>>:['a/b', 'c', 'd.txt']

7).isdigit　#用来判断字符串里面是否为纯数字

# 判断字符串是否是纯数字组成，返回结果为True或False 
str8 = '5201314' 
print(str8.isdigit()) 
>>>:True

str88 = '123g123' 
print(str88.isdigit()) 
>>>:False

8).replace    # 替换

a = 'my name is li, my age is 18'
print(a.replace('18', '20'))   # 语法为replace('旧内容', '新内容')
>>>:my name is li, my age is 20
print(a.replace('my', 'My', 1))    # 只把一个my改成My
>>>:My name is li, my age is 18

5.了解操作

1）find,rfind,index,rindex,count

msg='hello world'
#find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1 
msg.find('o',1,3) # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引 

#index:同find,但在找不到时会报错 
print(msg.index('e',2,4))    

#count:统计字符串在大字符串中出现的次数
print(msg.count('e'))  # 统计字符串e出现的次数 
print(msg.count('e',1,6))  # 字符串e在索引1~5范围内出现的次数 

2）center,ljust,rjust,zfill

name='hello' 

print(name.center(30, '-'))  # 总宽度为30，字符串居中显示，位数不够用-填充
>>>: -------------hello-------------
print(name.ljust(30, '*'))   # 总宽度为30，字符串左对齐显示，位数不够用*填充
>>>:hello************************** 
print(name.rjust(30, '*'))   # 总宽度为30，字符串右对齐显示，位数不够用*填充 
>>>:**************************hello
print(name.zfill(50))        # 总宽度为50，字符串右对齐显示，位数不够用0填充 
>>>:0000000000000000000000000000000000000000000000hello

3）captalize,swapcase,title

message = "heLLo World"

print(message.capitalize())    # 首字母大写,其余部分都变为小写
>>>:Hello world
print(message.swapcase())    # 大小写翻转
>>>:HEllO wORLD
print(message.title())    # 每个单词的首字母大写
>>>:Hello World

列表(list)

1.定义

　　在[ ]内，用逗号分隔开多个任意数据类型的值。

2.类型转换

# 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中 
print(list('wdad'))    # 字符串
>>>:['w', 'd', 'a', 'd']   
print(list([1,2,3]))  # 列表
>>>:[1, 2, 3]
print(list({"name":"lili","age":18}))   # 字典
>>>:['name', 'age'] 
print(list((1,2,3)))  # 元组
>>>:[1, 2, 3]
print(list({1,2,3,4}))    # 集合
>>>:[1, 2, 3,4]

3.常用操作

1）按索引存取值(正向存取+反向存取)：即可存也可以取

a = ['11','22','33',4,5] 
print(a[0])   # 正向取(从左往右) 
>>>:'11' 
print(a[-1])  # 反向取(负号表示从右往左) 
>>>5 
# 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错 
a[1] = '2222' 
print(a)
>>>:['11', '2222', '33', 4, 5] 

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

# 顾头不顾尾：取出索引为0到3的元素 
a = ['11', '22', '33', '44','55']
print(a[0:4])
>>>:['11', '22', '33', 4] 
print(a[0:4:2])  # 第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
>>>:['11', '33']

 3）长度

a = ['11', '22', '33', '44', '55']
print(len(a))
>>>:5

4）成员运算in和not in

a =['11', '22', '33', '44', '55']
print('11' in my_friends )　　 
>>>:True 
print('111' not in my_friends )　　 
>>>:False

5）添加

# 5.1 append()列表尾部追加元素 
>>> l1 = ['a','b','c'] 
>>> l1.append('d') 
>>> l1 ['a', 'b', 'c', 'd'] 

# 5.2 extend()一次性在列表尾部添加多个元素 
>>> l1.extend(['a','b','c']) 
>>> l1 ['a', 'b', 'c', 'd', 'a', 'b', 'c'] 

# 5.3 insert()在指定位置插入元素 
>>> l1.insert(0,"first") # 0表示按索引位置插值 
>>> l1 ['first', 'a', 'b', 'c', 'alisa', 'a', 'b', 'c']

6）删除

# 6.1 del 
>>> l = [11,22,33,44] 
>>> del l[2] # 删除索引为2的元素 
>>> l [11,22,44] 

# 6.2 pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素 
>>> l = [11,22,33,22,44]
>>> res=l.pop() 
>>> res 44 
>>> res=l.pop(1) 
>>> res 22 

# 6.3 remove()括号内指名道姓表示要删除哪个元素，没有返回值 
>>> l = [11,22,33,22,44] 
>>> res=l.remove(22)    # 从左往右查找第一个括号内需要删除的元素 >>> print(res) None 

7）reverse()颠倒列表内元素顺序

>> l = [11,22,33,44] 
>>> l.reverse() 
>>> l [44,33,22,11] 

8）sort()给列表内所有元素排序

# 8.1 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错 
>>> l = [11,22,3,42,7,55] 
>>> l.sort() >>> l [3, 7, 11, 22, 42, 55] # 默认从小到大排序 
>>> l = [11,22,3,42,7,55] 
>>> l.sort(reverse=True)  # reverse用来指定是否跌倒排序，默认为False 
>>> l [55, 42, 22, 11, 7, 3] 
# 8.2 了解知识： 
# 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如 
>>> l1=[1,2,3] 
>>> l2=[2,] 
>>> l2 > l1 
True   

# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大 >>> s1='abc' 
>>> s2='az' 
>>> s2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立 
True 

# 所以我们也可以对下面这个列表排序 
>>> l = ['A','z','adjk','hello','hea'] 
>>> l.sort() >>> l ['A', 'adjk', 'hea', 'hello','z'] 

# 9.循环 
# 循环遍历my_friends列表里面的值 
for line in my_friends: 
print(line) 
　　'11' '22' '33' 4 5

4.了解操作

>>> l=[1,2,3,4,5,6] 
>>> l[0:3:1] [1, 2, 3] 
# 正向步长 
>>> l[2::-1]
     [3, 2, 1] 
# 反向步长 # 通过索引取值实现列表翻转 
>>> l[::-1] 
    [6, 5, 4, 3, 2, 1]

p移除字符串首尾指定的字符(默认移除空格)