数字类型、字符串及列表的内置方法

今日内容：

一. 数字类型

二. 字符类型及内置方法

三. 列表内容及内置方法

数字类型：

1. 用途：记录年龄、登记、号码等整数

2. 定义方式：

age = 18  # 实质上相当于age = int(18)

print(type(age))  # 结果显示为int类型

ps：int只能将字符串中包含纯数字转成整型，如int("10.1")、int("nefiejne")都会报错，无法转换。

 

进制转换：*********

① 十进制转其他进制：

print(bin(12))  # bin代表十进制转二进制

print(oct(12))  # oct代表十进制转八进制

print(hex(12))  # hex代表十进制转十六进制

 

②其他进制转十进制：

print(int(10,2))  # int代表转换，10代表要转换的数字，2代表要转换的进制
print(int(10,8))  # int代表转换，10代表要转换的数字，2代表要转换的进制
pirnt(int(10,16))  # int代表转换，10代表要转换的数字，16代表要转换的进制

 字符串类型：

1. 用途：描述性

2. 定义方式：

三种方式  第一种：单引号''   第二种：双引号""  第三种：三引号""""""

 s = 'hello'  # 实质上相当于s = str('hello')

print(type(s))  # 结果显示为str类型

3. 内置方法：

①按索引取值（正向取+反向取）：只能取值，不能存储值

s = 'fine'
print(s[2])  # 结果为n    索引是以0开始的，n在第三位，所以取值顺序为0,1,2

 ②切片：从从一个大的字符串中截取一段新的小字符串     （特点：顾头[左边]不顾尾[右边]，步长）

1）：正向取值

i = 'you are beautiful'
print(i[2:6])  # 结果是u ar

print(i[1:5:1])  # 结果为ou a 
print(i[1:5:2])  # 结果为o

2）：反向取值

i = 'you are beautiful'
print(i[-1])  # 结果为l，表明反向取值
print(i[0:4:-1])  # 结果不显示，表明在0:4这个从左往右的顺序中取不到索引值为-1的字符
print(i[4:0:-1])   # 结果为a uo，分别代表索引值为4、3、2、1的字符被反向取出

i = 'you are beautiful'
print(i[-1])  # 结果为l，表明反向取值
print(i[0:4:-1])  # 结果不显示，表明在0:4这个从左往右的顺序中取不到索引值为-1的字符
print(i[4:0:-1])   # 结果为a uo，分别代表索引值为4、3、2、1的字符被反向取出

ps：[]里面的前两个数字代表取值范围，后面数字默认为1，人为定义的话就是“步长”，就是在取值范围内每“步长”长度内取一个值。

③长度len：统计的是字符串中字符的个数

o = 'beautiful'
print(len(o))  # 结果为9，表明o里面有9个字符，一个字母代表一个字符

 ④成员运算（in 和not in）：判断一个子字符串是否存在于一个大的字符串中

i = 'beautiful handsome rich'
print('b' in i)  # True
print('hand' in i)  # True
print('tful' not in i)  # True

 ⑤strip（去掉字符串两端的字符，只剩下中间的） 

ID = input(':')
if ID == '英雄好汉' ：
    print('原来是你')
# 此时需要输入“英雄汉好”才能进入

ID = input(':').strip()  # 标准格式为   .strip()
if ID == '英雄好汉' :
    print('原来是你')
# 此时，假如输入“英雄好汉”时不小心在前面或者后面多打了空格，也能正常进入
# .strip()默认去除字符串首尾的空格

ID = '%$&^*英雄好汉%&*'
print(ID.strip('%$^*'))  # 结果为   英雄好汉
# .strip()可自定义括号中想要去除的符号

同时，还有lstrip以及rstrip,分别代表仅去除左边的符号和仅去除右边的符号

 ⑥split（切分）：针对按照某种分隔符组织的字符串，可以用split将其切分成列表，进而进行取值

print(name.split('、'))  # 结果为  ['赵'，'钱'，'孙'，'李']  

ps：可以看到生成的是列表

注：split切割的顺序默认为从左往右的，可分为lsplit和rsplit，其中lsplit和split的效果是一样的。

name = '赵、钱、孙、李'
print(name.split('、',1))  # 结果为 ['赵', '钱、孙、李']
# .split()中括号内可以自定义，前面是要切割的标志符号，后面是次数。

 

⑦ 循环：

name = '赵、钱、孙、李'
for o in name :
    print(o)
# 结果为：
赵
、
钱
、
孙
、
李

 

*****************************（需要掌握的）

1. strip,lstrip,rstrip

2. lower（小写）,upper（大写）

a = 'qweRTY'
print(a.lower())  # qwerty
print(a.upper())  # QWERTY

3. startswith（以..开头），endswith（以..结尾）

i = 'beautiful'
print(i.startswith('b'))  # True  判断字符是否已()开头
print(i.startswith('e'))  # False  判断字符是否已()开头
print(i.endswith('l'))   # True  判断字符是否已()结尾
print(i.endswith('u'))  # False  判断字符是否已()结尾

 4. format的三种用法（在python中推荐使用format做格式化输出）

第一种：按照位置占位，相当于%s，如：

list = 'his name is {} he was {} years old'.format('赵',24)
print(list)  # his name is 赵 he was 24 years old

# 哪个位置需要就在哪个位置占位子，并一一对应

 

第二种：按索引占位，如：

list = 'his name is {1} and he was {0} years old'.format(18,'赵')
print(list)  # 结果为 his name is 赵 and he was 18 years old

# 1对应的索引值为'赵'，0对应的索引值为18

 

 第三种：关键字传参（指名道姓），如：

list = 'his name is {name} and he was {age} years old'.format(name = '赵',age = 18)
print(list)  # 结果为  his name is 赵 and he was 18 years old
# 先占位，后直接指定对应的值

 

5. split,rsplit

6. join：将容器类型中的多个元素通过指定字符拼接成一个字符串，如：

list = '我是字符串'
list = '18'.join(list)
print(list)  # 结果为 我18是18字18符18串

# 在每个元素中间加入想加入的值

 

 7. replace：替代

list = 'I am your partner'
res = list.replace('I am','We are')
print(res)  # 结果为 We are your partner

# 格式为  .replace()，括号里前面为要选取的，后面为想要代替的；还可以在后面跟一个数字，代表替换的次数。

 

8. isdigit： 判断字符串中包含的是否为纯数字，如：

age = input(':').strip()
if age.isdigit() :
    age = int(age)
    if age > 30 :
        print('年龄太大了')
    else :
        print('可以，欢迎')

# 当输入25时，打印出“可以，欢迎”，表明此时识别出了25是纯数字；
# 当输入25.1时，无结果显示，表明纯数字无法识别。

 

 需要了解的内置方法///

1. find：index：count：

# .find()：表示()里字符的索引值，找不到时返回结果为-1，并不会报错

# .index()：返回()里所传字符所在的索引值

# .count()：统计()里字符出现的次数

2. center：ljust：rjust：zfill：

i = '我是谁？'
print(i.center(50,'+'))  # +++++++++++++++++++++++我是谁？+++++++++++++++++++++++
print(i.ljust(25,'+'))  # 我是谁？+++++++++++++++++++++
print(i.rjust(25,'+'))  # +++++++++++++++++++++我是谁？
print(i.zfill(50,))  # 000000我是谁？

# center：将i居中，两侧用一定数量的符号填满
# ljust：将i放在左边，右边用一定数量的符号填满
# rjust:将i放在右边，左边用一定数量的符号填满
# 当应空格符号填满时，可以分别理解为“居中”“左对齐”“右对齐”指令

# zfill:用0将i添补到一定字符数

3. expengtabs：

4. captalize：swapcase：title：

s = 'we BUy'
print(s.capitalize())  # We buy     作用：首字母大写
print(s.swapcase())  # WE buY     作用：大小写互换
print(s.title())  # We Buy  每单词首字母大写

 

5. is数字系列：

isnumeric()   ：阿拉伯数字，中文数字，罗马数字都可以识别

isdecimal()   ：只识别普通的阿拉伯数字

isdigit()   ：识别bytes和阿拉伯数字  # （一般情况下使用isdigit()就已经满足需求了）

**************

字符串类型存的是一个值，有序的，不可变类型。

PS：当值变化，id不变，那么是可变类型；值变化，id也变化的，是不可变类型。

列表类型：

1. 作用：存储多个键值对

2. 定义：[]内可以有多个任意类型的值，用逗号隔开；

i = ['h','u',1,'我']  # 本质上相当于i = list['h','u',1,'我']

# list内部原理就是for循环取值，然后一个个存到列表中

*****************

优先掌握的：

1. 列表是按索引取值，既可以存储也可以取出，且正向反向都可以进行存取

u = [1,2,3,4]
print(u[0:4:1])  #[1, 2, 3, 4]  []内第一个值表示索引起始位置，第二个代表索引结束为止，第三个值代表步长
print(u[0::])  # [1, 2, 3, 4]  []内第一个值表示索引其实为止，第二个值默认为最大索引值，第三个值默认为步长为1
print(u[5::-1])  # [4, 3, 2, 1]  []内第一个值大于第二个值时，表示反向索引

2. 切片（顾头不顾尾，步长）：

l=['egon','lxx','yxx',444,555,66666]
print(l[0:5])  # ['egon', 'lxx', 'yxx', 444, 555]   表示打印出索引值为0-5的元素
print(l[0:5:2])  # ['egon', 'yxx', 555]  表示每隔一个元素打印出索引值为0-5的元素
print(l[::-1])  # [66666, 555, 444, 'yxx', 'lxx', 'egon']  表示反向打印所有元素

 

3. 添加容器类型数据：

①append：将添加的数据当做列表的一个元素（尾部）

②insert：通过索引在任意位置添加元素（能将被添加的数据当做列表的一个元素）

③extend：通过for循环一个个将元素加到列表的尾部

4. 长度（len）：结果为元素个数

5. 成员运算in和not in 

6. 往列表中加元素：三个关键词：append  insert  extend

7. 删除：

①单纯的删除del ：

i = [5,4,6,8,9,7]
print(i)  # [5, 4, 6, 8, 9, 7]  打印i这个变量的值
del i[2]
print(i)  # [5, 4, 8, 9, 7]  打印删除对应索引数为2的第三个值

# del适用于所有的删除操作

 

②remove：

i = [1,2,3,4,5,6]
print(i)  # [1, 2, 3, 4, 5, 6]  打印i变量的元素
i = i.remove(2)
print(i)  # None  指定要删除的值，返回是None

③pop：

i = [1,2,3,4,5,6]
print(i)  # [1, 2, 3, 4, 5, 6]   打印i变量的元素
i1 = i.pop(2)
print(i1)  # 3  按照索引弹出来的元素，返回的是弹出的那个值

 

8. 循环：原理是for循环

*********************

列表类型存在多个值，是有序可变的

9. count：计次数

f = ['a','x',1,3,3,3,8,'c']
print(f.count(3))  # 3 表明3在f这个列表中出现的次数为3

 10. clear：清除

print(f.clear())  # None
print(f)  # []  已被清空

 

 11. reverse：反转

f = ['a','x',1,3,3,3,8,'c']
print(f.reverse())  # None
print(f)  # ['c', 8, 3, 3, 3, 1, 'x', 'a']  元素全被反过来

 

12.  sort：排序，并且默认从小到大：

f = [1,24,63,2,35]
f.sort()
print(f)  # [1, 2, 24, 35, 63]可以看出来进行了从小到大的排序
f.sort(reverse = True)
print(f)  # [63, 35, 24, 2, 1]进行了反转操作

 

13. 队列（先进先出）：用pop弹出，用索引，先弹出第一位，再一次弹出

     堆栈（先进后出）：用pop弹出，默认为从最后一个弹出

 

转载于:https://www.cnblogs.com/pupy/p/11127877.html