数字类型

数字类型分为整型，浮点型，布尔型

1.整型

num = -1000000000000000000000000000000000000000000000000

print(num, type(num))

-100000000000000000000000000 <class 'int'>

 

py2中小整数用int存放，大整数用long，而在py3中取消了长整型全部用int，数值过大的会被当作字符串保存。

2.小数

num = 3.14

print(num, type(num))

<class 'float'>

 

3.布尔

res = True

print(res, type(res), isinstance(res, int))

print(3.14 + True)

True <class 'bool'> True

4.140000000000001

 

重点：数字类型直接的相互转化 *****

a = 10

b = 3.74

c = True

print(int(a), int(b), int(c))

print(float(a), float(b), float(c))

print(bool(a), bool(b), bool(c))

int只能将纯数字转化为整型

float只能将含有小数的数字转化为浮点型

布尔型本质为0和1，0代表false1代表true.

字符串类型

1.定义: 可以有多种引号嵌套

需求：你是"好学生"

s1 = "你是\"好学生\""

print(s1)

你是"好学生"

-------------

s2 = '你是"好学生"'

print(s2)

你是"好学生"

单引号和双引号可以互相嵌套，但开头和结尾为单引号或双引号时可以使用三引号

字符串的常规操作

1.字符串的索引取值: 字符串[index]

正向取值从0编号，反向取值从-1编号

s1 = '123abc呵呵'

print(id(s1)) # 2217572683576

print(s1[0], id(s1[0])) # 2217543167200

t_s = '1'

print(id(t_s)) # 2217543167200

2.字符串拼接

 s2 = '你好'

s22 = '帅'

ss2 = s2 + s22

print(ss2, id(s2), id(s22), id(ss2))

字符串可以直接拼接但是拼接后的字符串会开辟出新的内存来存储

如果要拼接其他类型（str--字符串）

a = 10

b = "20"

c = True

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

print(res)

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

print(res)

不同数据类型可以直接拼接但是必须要先转换为字符串类型

 3.字符串长度

s3 = '12345'

ln1 = s3.__len__()

print(ln1)

ln2 = len(s3)

print(ln2)

5

5

 .__len__()作为魔法变量用来计算字符串长度

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

2

3

a

b

c

呵

呵

每次循环输出字符串中的单个数值

重要方法

1.索引index(目标字符串的索引位置)

s1 = '123abc呵呵'

print(s1.index('b'))

4

index可以找出目标字符在字符串中的位置

 

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:')#以https开头

r2 = s6.startswith('http:') 

r3 = s6.endswith('com')  #以com结尾

r4 = s6.endswith('cn')

if (r1 or r2) and (r3 or r4):

print('合法的链接')

else:

print('非合法的链接')

 

7.替换

s7 = 'egon say: he is da shuai b，egon！egon！egon！'

new_s7 = s7.replace('egon', '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")) # 指名道姓

 

1. find | rfind：查找子字符串索引，无结果返回-1

2. lstrip：去左留白

3. rstrip：去右留白

4. center | ljust | rjust | zfill：按位填充

语法：center(所占位数, '填充符号')

5. expandtabs：规定\t所占空格数

6. captialize | title | swapcase：首字母大写 | 单词首字母大写 | 大小写反转

7. isdigit | isdecimal | isnumeric：数字判断

8. isalnum | isalpha：是否由字母数字组成 | 由字母组成

9. isidentifier：是否是合法标识符

10. islower | isupper：是否全小 | 大写

11. isspace：是否是空白字符

12. istitle：是否为单词首字母大写格式

 

列表类型

list中可以存放多个值，可以存放所有类型的数据

list中有序的，可以通过索引取值

1.索引取值: 列表名[index] s1 = [1, 3, 2] print(s1[0]) 0 print(s1[-1]) 2 在列表名后以[]的格式获取相应位置的数值，查找的为负数时会从后往前查找

2.列表运算: 得到的是新list s2 = [1, 2, 3] print(s2 + s2) [1, 2, 3, 1, 2, 3] print(s2 * 2) [1, 2, 3, 1, 2, 3] print(s2) [1, 2, 3] 列表可以相加，相加后列表内的数值会合并。列表做乘法运算之后数值会翻倍累加

.list的长度 s3 = [3, 4, 1, 2, 5] print(len(s3)) 5 len（list）可以计算出列表内数值的个数

4.切片：[start_index:end_index:step] s4 = [3, 4, 1, 2, 5] new_s4 = s4[::-1] print(new_s4) new_s4 = s4[1:4:] print(new_s4) new_s4 = s4[-2:-5:-1] print(new_s4) list切片的格式为 list[开始索引：结束索引：步长]

　　步长为负的话会倒叙输出

5.成员运算：in s5 = [3, 4, '1', 2, 5] print('1' in s5) print(1 in s5) print(5 not in s5) 判断目标数值是否在列表中，输出结果为布尔值

6.循环

s5 = [3, 4, '1', 2, 5]

for v in s5:     print(v, type(v))

3 <class 'int'>

4 <class 'int'>

1 <class 'str'>

2 <class 'int'>

5 <class 'int'>

for v in s5:     if isinstance(v, int):         print(v, end=' ')

3 4 2 5 

列表操作

1.列表的增删改查 ls = [1, 2, 3]

查 print(ls) print(ls[1]) 2

增 ls.append(0)  # append可以在列表末尾增加‘0’ print(ls) [1, 2, 3, 0] ls.insert(1, 666)  # insert可以在任意index前增 print(ls) [1, 666, 2, 3, 0]

ls.insert(len(ls), 888)  # insert实行末尾增 print(ls) [1, 666, 2, 3, 0, 888]

改 ls[1] = 66666  #直接吧目标数字更改 print(ls) [1, 66666, 2, 3, 0, 888]

删 ls.remove(888)   #直接删除目标数值 print(ls) res = ls.pop()  # 默认从末尾删，并返还删除的值 print(res) res = ls.pop(1)  # 从指定索引删除，并返还删除的值 print(res, ls)

了了解 del ls[2]  #del也可以指定索引删除但还是不会返还值 print(res, ls) # 清空 ls.clear() print(ls)

排序: 针对于同类型 ls = ['3', '1', '2'] ls.sort()  # 默认正向排序 print(ls) ['1', '2', '3'] ls.sort(reverse=True)  # 正向排序结果上翻转，形成倒序 print(ls) ['3', '2', '1']

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

计算值的个数 => 列表中可以存放重复数据 ls = [1, 2, 1, 2, 3, 1] print(ls.count(1))  # 对象1存在的次数

整体增加，添加到末尾 ls = [1, 2, 3] ls.extend('123') print(ls) ls.extend([0, 1, 2]) print(ls)

目标的索引位置，可以规定查找区间 ls = [1, 2, 1, 2, 3, 1] # 找对象1，在索引3开始往后找到索引6之前 ind = ls.index(1, 3, 6) print(ind)

可便于不可变类型

ls = [10, 20, 30] print(id(ls), ls) ls[0] = 100 print(id(ls), ls) print(id(10)) print(id(20)) print(id(100)) print(id('100'))