Python Day5

痛定思痛。 2022-01-07 02:49 248阅读 0赞

### 一、数字类型 ###

1.整型：

num = 500000

print(num,type(num))

2浮点型（小数）：

num = 5.62

print(num,type(num))

bool:

True:是有值的

列子：

res = True  
print(res, type(res), isinstance(res, int))  
print(3.14 + True)结果为4.14

False

复数（complex）：

num = complex(5, 4)  \# 5 + 4j（左边为实数，右边为虚数加j）

重点：数据类型可以直接转化

a=3

b=5.2

c=True

print(int(a），int(b),int(c))    输出结果为 3,5,1

float 和bool同理

### 字符串（str） ###

就是在引号内包含多个字符，但仍然还是一个整体。

定义：可以有多种引号嵌套

''    "   "为单行字符串

‘’‘’‘’   “”“   ”“”   为多行字符串

列子：

你是"好学生"  
s1 = "你是\\"好学生\\""  
print(s1)  
可以通过引号的嵌套，使内部不同的引号在不转义的情况下直接输出  
s2 = '你是"好学生"'  
print(s2)

需求：你是"好学生"，是'我的'  
s3 = """你是"好学生"，是'我的'"""  
print(s3)

#### 字符串的常规操作： ####

1.字符串的索引取值: 字符串\[index\]  
正向取值从0编号，反向取值从-1编号

列子：  
s1 = '123abc呵呵'  
取出c  
print(s1\[5\], s1\[-3\])

\# 2.字符串拼接

列子：  
s2 = '你好'  
s22 = '帅'  
ss2 = s2 + s22  
如果要拼接其他类型  
a = 10  
b = "20"  
c = True  
 结果：res = "1020True"

方法1：  
res = "%s%s%s" % (a, b, c)   
print(res)

方法2：  
res = str(a) + b + str(c)   
print(res)

3.字符串长度

列子：  
s3 = '12345'  
ln1 = s3.\_\_len\_\_()  
print(ln1)  
ln2 = len(s3)  
print(ln2)

4.字符串切片: 取子字符串 - \[::\] - \[start\_index:end\_index:step\]

列子：  
s4 = '123abc呵呵'  
sub\_s = s4\[0:6:\]  
print(sub\_s) 结果为：123abc  
sub\_s = s4\[0:6:2\]  
print(sub\_s) 结果为：13b  
sub\_s = s4\[::-1\]  
print(sub\_s) 结果为：呵呵cba321  
sub\_s = s4\[-1:-6:-1\]  
print(sub\_s) 结果为：呵呵cba

5.成员运算：判断某字符串是否在该字符串中

列子：  
s5 = '123abc呵呵'  
ss5 = '12a'  
print(ss5 in s5)         False  
print(ss5 not in s5)        True

按顺序判断  
 6.字符串循环(遍历)  
s6 = '123abc呵呵'  
for v in s5:  
print(v)

#### 重要方法： ####

1.索引(目标字符串的索引位置)  
s1 = '123abc呵呵'  
print(s1.index('b'))结果为4

2.去留白(默认去两端留白，也可以去指定字符)  
s2 = '\*\*\*好 \* 的 \*\*\*'  
print(s2.strip('\*'))

3.计算子字符串个数  
s3 = '12312312'  
print(s3.count('123'))

4.判断字符串是否是数字:只能判断正整数  
s4 = '123'  
print(s4.isdigit())

5.大小写转换  
s5 = "AbC def"  
print(s5.upper())  全大写ABC DEF  
print(s5.lower())  全小写abc def  
了解  
print(s5.capitalize()) 首字母大写Abc def  
print(s5.title())  每个单词首字母大写Abc Def

6.以某某开头或结尾  
s6 = 'https://www.baidu.com'  
r1 = s6.startswith('https:')  
r2 = s6.startswith('http:')  
r3 = s6.endswith('com')  
r4 = s6.endswith('cn')  
if (r1 or r2) and (r3 or r4):  
print('合法的链接')  
else:  
print('非合法的链接')  
  
 7.替换

列子：  
s7 = 'lion say: he is da shuai b，lion！lion！lion！'  
new\_s7 = s7.replace('lion', 'Liu某')  默认替换所有  
print(new\_s7)  
new\_s7 = s7.replace('egon', 'Liu某', 1)  替换一次  
print(new\_s7)

8.格式化

列子：  
s8 = 'name：\{\}，age：\{\}'  
print(s8.format('Owen', 18))  默认按位置  
print('name：\{1\}，age：\{1\}, height：\{1\}'.format('Owen', 18)) 标注位置，一个值可以多次利用  
print('name：\{n\}，age：\{a\}, height：\{a\}'.format(a=18, n="Zero")) 指名道姓

### 扩展： ###

### 列表： ###

定义：

在\[\]中用，分隔开多个任意类型的值

列表中按索引取值，索引都是从0开始

#### 常规操作： ####

1.索引取值: 列表名\[index\]

列子：  
s1 = \[1, 3, 2\]  
print(s1\[0\])     1       
print(s1\[-1\])    2

2.列表运算: 得到的是新list

列子：  
s2 = \[1, 2, 3\]  
print(s2 + s2)  \[1,2,3,1,2,3\]  
print(s2 \* 2)同上  
print(s2)

3.list的长度

列子：  
s3 = \[3, 4, 1, 2, 5\]  
print(len(s3))结果为5

4.切片：\[start\_index:end\_index:step\]  
s4 = \[3, 4, 1, 2, 5\]  
new\_s4 = s4\[::-1\]结果为 5,2,1,4,3  
print(new\_s4)  
new\_s4 = s4\[1:4:\]结果为;4,1,2  
print(new\_s4)  
new\_s4 = s4\[-2:-5:-1\]结果为：2，1，4  
print(new\_s4)

5.成员运算：in

列子  
s5 = \[3, 4, '1', 2, 5\]  
print('1' in s5)  
print(1 in s5)  
print(5 not in s5)

6.循环  
for v in s5:  
print(v, type(v))

只打印数字类型的数据  
for v in s5:  
if isinstance(v, int):  
print(v, end=' ')

### 增删改查： ###

列表的增删改查列子:

ls = \[1, 2, 3\]

增：

ls.append(0) 在末尾增  
print(ls)  
ls.insert(1, 666) 任意index前增  
print(ls)  
ls.insert(len(ls), 888)  insert实行末尾增  
print(ls)

删：

ls.remove(888)  
print(ls)  
res = ls.pop() 默认从末尾删，并返还删除的值  
print(res)  
res = ls.pop(1)  从指定索引删除，并返还删除的值  
print(res, ls)  
了解：  
del ls\[2\]  
print(res, ls)  
清空  
ls.clear()  
print(ls)

### 了解的方法： ###

1.排序: 针对于同类型

列子：  
ls = \['3', '1', '2'\]  
ls.sort()  默认正向排序  
print(ls)  
ls.sort(reverse=True)  正向排序结果上翻转，形成倒序  
print(ls)

2.翻转

列子：  
ls = \['3', '1', '2'\]  
ls.reverse() 按存储的顺序进行翻转  
print(ls)

3.计算值的个数 => 列表中可以存放重复数据

列子：  
ls = \[1, 2, 1, 2, 3, 1\]  
print(ls.count(1))  对象1存在的次数

### 拓展： ###

1.整体增加，添加到末尾

列子：  
ls = \[1, 2, 3\]  
ls.extend('123')  
print(ls)  
ls.extend(\[0, 1, 2\])  
print(ls)

2.目标的索引位置，可以规定查找区间

列子：  
ls = \[1, 2, 1, 2, 3, 1\]  
 找对象1，在索引3开始往后找到索引6之前  
ind = ls.index(1, 3, 6)  
print(ind)