基本数据类型数字类型、字符串、列表、元组

目录：
1、数据类型int与float
2、字符串
3、列表
4、元组

一、数据类型int与float
1.1 定义：
int为整型
>>>age=10 # 本质 age=int（10）
float为浮点型
salary=3000.1 本质 salary=float（3000.1）
## 注意： 名字+括号的意思是调用某个功能
1.2 类型转换

age=‘18’
num = int (age)
num = 18
type(age) ,type(num)
(<class’str’>),(<class’int’>)

int可以将纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错。

二、字符串
2.1、定义：
在单引号、双引号、三引号内包含一串字符，如字符串里面有单引号的，外面必须用双引号。

name1=‘alen’
#本质是 name1=str（‘alen’）括号内也可以是任意类型
name2=“blue”
#本质是 name2=str（“blue”）括号内也可以是任意类型
name3=""“egon”""
#本质是 name3=str（""“egon”""）括号内也可以是任意类型

2.2 、类型转换
str()可以将任意类型转换成字符串类型

a=[1,2,3]
s=str(a)
s=’[1,2,3]’

如上，list->str , dict->str , tuple -> str , set -> str

2.3、使用
》》 优先掌握的操作
str1 = ‘hello python’
2.3.1、按照索引取值（正向取，反向取）

正向取：
str[4]
o
反向取：
str[-1]
n
对于str来说，只能按照索引取值，不能改，否则报错TypeError

2.3.2、切片（顾头不顾尾，步长）

》顾头不顾尾是指，只能取出索引值0至8的所有字符
str1[0:9]
hello pyt
》步长0：9：2，第三个参数2代表步长，从0开始，每次累加一个2即可，所以会取出0、2、4、6、8的字符
str1[0:9:2]
hlopt
》反向切片
str1[::-1] # -1表示 从右往左切
nohtyp olleh

2.3.3 、 长度 （len）

获取字符串的长度，既引号内的字符个数 ，引号内的所有字符都算数，报错空格。
len(str1)
12

2.3.4 、 成员运算 in 和 not in

判断字符是否在字符串中。
‘hello’ in str1
True

2.3.5 、 strip,lstrip,rstrip 移除字符串首尾指定的字符 和 移除字符串左边指定字符 和 移除字符串右边指定字符 （默认移除空格）

》括号内不指定字符，默认移除字符串首尾的空白字符（空格、、\n、\t）
str1=‘alen’
str1.strip(’’)
‘alen’
str1.lstrip(’’)
‘alen*****’
str1.rstrip(’*’)
‘*****alen’

2.3.6 、切分 split 左往右切 ，rsplit 刚好与split相反，是从右往左切，都可以指定切割次数

括号内不指定字符，默认以空格作为切分符号
str2=‘hello world’
str2.split()
[‘hello’,‘world’]
括号内指定分隔字符，则按照括号内指定的分隔字符切割字符串，同时指定切割次数。
str3=‘12.3.46’
str3.split(’.’,1)
[‘12’,‘3.46’]
str4=‘a/b/c/d’
str4.rsplit(’/’,1)
[‘a/b/c’,‘d’]
注意：split切割出来的结果是列表数据类型

2.3.7、for 循环

str4 = ‘早上好啊！’
for line in str4: # 依次取出字符串中的每一个值
print(line)
…
早
上
好
啊
！

》》需要掌握的操作类型

2.3.8 lower() # 将英文字符串全部变成小写
upper() # 将英文字符串全部变成大写

str1=‘My NaMe is Alen’
str1.lower() # 变小写
‘my name is alen’
str1.upper() # 变大写
’MY NAME IS ALEN’

2.3.9 startswith,endswith，判断字符串是否以括号内指定字符开头或结尾，返回结果为True 或 False

str2 = ‘hello alen’
str2.startswith(‘s’)
True
str2.endswith(‘n’)
True

2.4.0、格式化输出%s、%d、format

》什么是格式化输出？

把一串字符串里面的某些内容替换掉之后再输出，就是格式化输出

》为什么要格式化输出？

当遇到固定格式的内容的时候，如：'我的名字是XXX，我今年XX岁了，我的兴趣爱好是XXX'，我们需要做的就是将XXX更换成具体的内容。

》如何格式话输出？

首先介绍占位符，如%s、%d
%s占位符：可以接收任意类型的值
%d占位符：只能接收数字
print(‘我的名字是%s，我今年%d岁了，我的兴趣爱好是%s.’%(‘alen’,18,‘basketball’))
我的名字是alen，我今年18岁了，我的兴趣爱好是basketball

练习1：接收用户输入，打印成指定格式。
name=input(‘your name:’)
age = input(‘your age:’) # 用户输入18，会被input转成字符串，无法传送给%d。
print(‘My name is %s,my age is %s’%(name,age))

练习2：用户输入姓名、年龄、爱好、身高，然后的打印成下列格式：
-------------info--------------
name : alen
age : 18
hobby : basketball
height : 180
-------------end---------------

》然后介绍format
之前我们使用%s、%d来做字符串格式化输出操作，在传值的时候必须严格按照%s位置一一对应，而format提供了一种不依赖位置对应的方式传值。
str3=‘My name is {name},my age is {age}.’.format(age=18,name=‘alen’)
‘My name is alen,my age is 18’
formate也可以用%s的方法，按照位置对应来传值。
str3=‘My name is {},my age is {}.’.format(‘alen’,18)
My name is alen,my age is 18.
把format传入的多个值当作列表，然后按照索引来传值
str3=‘My name is {1},my age is {0}.’.format(18,‘alen’)
My name is alen,my age is 18.

2.4.1、 join 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串。

‘%’.join(‘hello’)
‘h%e%l%l%o’
‘|’.join([‘alen’,‘tony’,‘18’])
‘alen|tony|18’

2.4.2、replace 用ixn的字符替换字符串中旧的字符。

str=‘my name is alen,my age is 18’
str=str.replace(‘18’,‘20’)
str
my name is alen,my age is 20
可以指定修改的个数
str=‘my name is alen,my age is 18’
str=str.replace(‘my’,‘MY’,1)
str
MY name is alen ,my age is 18

2.4.2 、 isdigit 判断字符串是否以纯数字组成，返回结果为True 或 False

str=‘120845523’
str.isdigit()
True
str1=‘120a845523’
str.isdigit()
False

》》了解操作

2.4.3、 find,rfind,index,rindex,count
find：从指定范围内查找字符串的起始索引，找的到则返回字符索引，找不到则返回-1.

name=‘alen or tom’
print(name.find(‘t’,0,6)) # 在索引0-5内查找，顾头不顾尾
5
index同find,但在找不到的时候会报错：ValueError
rfind与rindex 都是反方向，从右开始。
count ：计数，统计字符在字符串中出现的个数。也可以根据索引指定范围。
name.count(‘o’)
2

2.4.4 、 center，ljust，rjust，zfill

name=‘tony’
name.center(30,’-’) # 总宽度为30，字符串居中显示，不够用-填充
-------------tony-------------
name.ljust(30,’’) # 总宽度为30，字符串左对齐显示，不够用填充
tony**************************
name.rjust(30,’’) # 总宽度为30，字符串右对齐显示，不够用填充
**************************tony
name.zfill(50) # 总宽度为50，字符串右对齐显示，不够用0填充
0000000000000000000000000000000000000000000000tony

2.4.5 、expandtabs

name = ‘tony\thello’ # \t表示制表符(tab键)
name
tony hello
name.expandtabs(1) # 修改\t制表符代表的空格数
tony hello

2.4.6、captalize,swapcase,title

message = ‘hello everyone nice to meet you!’
message.capitalize() # 首字母大写
Hello everyone nice to meet you!
swapcase：大小写翻转
message1 = ‘Hi girl, I want make friends with you!’
message1.swapcase()
hI GIRL, i WANT MAKE FRIENDS WITH YOU!
title：每个单词的首字母大写
msg = ‘dear my friend i miss you very much’
msg.title()
Dear My Friend I Miss You Very Much

2.4.7 、 is 数字系列
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
如果要判断中文数字或罗马数字,则需要用到isnumeric。
2.4.8 、is 其他

name = ‘tony123’
name.isalnum() #字符串中既可以包含数字也可以包含字母
True
name.isalpha() #字符串中只包含字母
False
name.isidentifier()#判断字符串是否有效，变量名是否合法
True
name.islower() # 字符串是否是纯小写
True
name.isupper() # 字符串是否是纯大写
False
name.isspace() # 字符串是否全是空格
False
name.istitle() # 字符串中的单词首字母是否都是大写
False

三、列表

3.1、 定义：在[]内，用逗号分隔开的多个任意数据类型。

3.2、类型转换

但凡能被for循环遍历的数据类型都可以传给list（），转换成列表数据类型。list（）会跟for循环遍历一样遍历出数据类型中的每一个元素然后放到列表中。
list(‘wdad’) # 结果：[‘w’, ‘d’, ‘a’, ‘d’]
list([1,2,3]) # 结果：[1, 2, 3] list({“name”:“jason”,“age”:18}) #结果：[‘name’, ‘age’]
list((1,2,3)) # 结果：[1, 2, 3]
list({1,2,3,4}) # 结果：[1, 2, 3, 4]

3.3、使用

》优先掌握的操作

3.3.1、按索引值存取值（正向存取+反向存取）

name=[‘alen’,‘tom’,‘blue’]
name[1] # 正向取值
tom
name=[‘alen’,‘tom’,‘blue’]
name[-1] # 反向取值
blue
name=[‘alen’,‘tom’,‘blue’]
name[0]=‘tony’ # 根据索引修改指定位置的值
name
[‘tony’,‘tom’,‘blue’]
注意：如果索引不存在，则会报错

3.3.2 切片 （顾头不顾尾，步长）

name=[‘tony’,‘alen’,‘tom’,‘blue’,‘lxx’,1,2,3]
name[0:4] #顾头不顾尾 ，实则取出的是0-3索引的值
[‘tony’,‘alen’,‘tom’]
步长：0：4：2，第三个参数2代表步长，会从索引0开始，每次累加一个2即可，最终取出的索引0、2
name=[‘tony’,‘alen’,‘tom’,‘blue’,‘lxx’,1,2,3]
name[0:4:2]
[‘tony’,‘tom’]

3.3.3、长度

len(‘my_name’)
7

3.3.4、成员运算 in 和 not in

tony in name
True

3.3.5、添加

》append（）列表尾部追加元素
aa=[1,2,3]
aa.append(‘as’)
aa
[1,2,3,‘as’]

》 extend（）一次性在列表尾部添加多个元素
aa.extend([4,5,6,7])
aa
[1,2,3,4,5,6,7]

》 insert（）在指定位置插入元素
aa.inser(0,‘one’) # 0表示按索引位置插入
aa
[‘one’,1,2,3]

3.3.6、删除

num=[1,2,3,4,5,6,7,8,9]
》del
del num[1] #删除索引为1的元素
num
[1,3,4,5,6,7,8,9]

》pop（）默认删除列表最后以一个元素，并将删除的值返回，也可以在括号内指定索引删除对应的值。
num.pop(2)
3

》remove（）括号内知名道姓表示要删除的元素，没有返回值。
res=num.remove(9)
print(res)
None

3.3.7、 reverse（）颠倒列表内元素顺序

num.reverse()
num
[9,8,7,6,5,4,3,2,1]

3.3.8 sort() 给列表内所有元素排序
排序时列表内的元素之间必须时相同的数据类型，否则报错

aa=[1,2,5,3,6,4]
aa.sort()
aa
[1,2,3,4,5,6] #默认是从小到大的顺序。

aa=[1,2,5,3,6,4]
aa.sort(reverse=True) #reserse用来指定是否跌倒排序，默认为False
aa
[6,5,4,3,2,1]

四、元组
元组与列表类似，也是可以存放多个任意类型的值，不同之处在于元组里的值不可以修改，既元素相当于不可变类型，用于记录多个不允许变得值，只用于取。

4.1 、定义方式
在（）内用逗号隔开得多个任意类型得值
》name=（‘alen’，‘tony’，‘blue’）
如果元组内只有一个值，则必须在值后面跟一个逗号，否则（）就是包含的意思而非元组。
name=（‘中国’，）

4.2 、类型转换
但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型

tuple(‘wdad’) # 结果：(‘w’, ‘d’, ‘a’, ‘d’)
tuple([1,2,3]) # 结果：(1, 2, 3)
tuple({“name”:“jason”,“age”:18}) # 结果：(‘name’, ‘age’)
tuple((1,2,3)) # 结果：(1, 2, 3)
tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)

tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

4.3、使用
元组的使用与列表基本相同，唯一不同之处在于元组里的元素不可以修改。否则报错：TypeError：