# 了了解：py2中小整数用int存放，大整数用long

# 1.整型

num = -1000000000000000000000000000000000000000000000000

print(num, type(num))

# 2.小数

num = 3.14

print(num, type(num))

# 3.布尔

res = True

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

print(3.14 + True)

# 4.复数

num = complex(5, 4)  # 5 + 4j

print(num + (4 + 5j))

#5. 重点：数字类型直接的相互转化 *****》》整型，浮点型，布尔之间直接相互转换不涉及所谓的四舍五入：

a = 10

b = 3.44

c = True

d = False

print(int(a), int(b), int(c),int(d)) #10 3 1 0

print(float(a), float(b), float(c),float(d)) #10.0 3.44 1.0 0.0

print(bool(a), bool(b), bool(c),bool(d)) #True True True False

数字类型

1.索引取值：只能取,正向取值从0编号，反向取值从-1编号

msg='hello world'

print(msg[4]) # o

print(msg[-1]) # d

# msg[3]='A'  # 报错

2.切片：就是从原符串中切分出一个全新的子字符串

注意：[start_index:end_index:step]

        1.包含初始值，不包含结束值，2.步长默认为1，正号正向取，步长为带负号数反向取 3.步长-1：为2个元素之间隔几个，前一个元素索引+步长：为下一个元素

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

3.字符串拼接，格式化输出

方式1：‘+’同类型拼接

s2 = '你好'

s22 = '帅'

print(s2 + s22) #你好帅

方式2：%s：万能占位符

# 如果要拼接其他类型

a = 10

b = ""

c = True

# res = "1020True"

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

print(res)

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

print(res)

方式3：format三种方法：位置，索引，关键字

s8 = 'name：{}，age：{}'

print(s8.format('Owen', 18))  # 默认按位置：name：Owen，age：18

print('name：{1}，age：{1}, height：{1}'.format('Owen', 18))  # 标注位置，一个值可以多次利用：name：18，age：18, height：18

print('name：{n}，age：{a}, height：{a}'.format(a=18, n="Zero"))  # 指名道姓：name：Zero，age：18, height：18

4.len(字符串)：字符串长度

s3 = ''

ln1 = s3.__len__()

print(ln1) #

ln2 = len(s3)

print(ln2) #

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

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.获取子字符串的索引：字符串.index（目标字符串）

s1 = '123abc呵呵'

print(s1.index('b')) #

2.去留白(默认去两端留白，也可以去指定字符)只能除出左右两端

s2 = '***好 * 的  ***'

print(s2.strip('*')) #好 * 的

s2 = '***$好 * 的  ***'

print(s2.strip('*$')) #好 * 的

拓展：

print('*****egon*****'.lstrip('*')) #egon*****

print('*****egon*****'.rstrip('*')) #*****egon

3.计算子字符串个数

s3 = ''

print(s3.count('')) #

4.字符串.isdigit():判断字符串是否是数字:只能判断正整数

s4 = ''

print(s4.isdigit()) #True

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 = 'egon say: he is da shuai b，egon！egon！egon！'

new_s7 = s7.replace('egon', 'Liu某')  # 默认替换所有:Liu某 say: he is da shuai b，Liu某！Liu某！Liu某！

print(new_s7)

new_s7 = s7.replace('egon', 'Liu某', 1)  # 替换一次:Liu某 say: he is da shuai b，egon！egon！egon！

print(new_s7)

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：是否为单词首字母大写格式

了解方法

#1.split,rsplit

msg='get|a.txt|333331231'

print(msg.split('|',1)) #['get', 'a.txt|333331231']

print(msg.rsplit('|',1)) #['get|a.txt', '333331231']

#2.join

msg='get|a.txt|333331231'

l=msg.split('|')

print(l) #['get', 'a.txt', '333331231']

src_msg='|'.join(l)

print(src_msg) #get|a.txt|333331231

增：

#1.尾增：列表.append(值）

ls1=['egon','lxx','yxx']

ls1.append(44444)

ls1.append(55555)

print(ls1) # ['egon', 'lxx', 'yxx', 44444, 55555]

#2.往指定索引前插入值：列表.insert(索引,值)

ls2=['egon','lxx','yxx']

ls2.insert(0,11111)

print(ls2) # [11111, 'egon', 'lxx', 'yxx']

ls2.insert(2,2222222)

print(ls2) # [11111, 'egon', 2222222, 'lxx', 'yxx']

#3. 整体增加，添加到末尾：列表.extend(列表或元组)

ls3 = ['jason','nick']

ls3.extend(['tank','sean'])

# ls3.extend(('tank','sean'))  #元组也可以

print(ls3) # ['jason', 'nick', 'tank', 'sean']

删：

# 方式1通用的：del 列表[删除值得索引]

ls1=['egon','lxx','yxx']

del ls1[1] # 通用的

print(ls1) #['egon', 'yxx']

# 方式2删除指定的值：列表.remove(要删除的值)

ls2=['egon','lxx','yxx']

res=ls2.remove('lxx') # 指定要删除的值，返回是None

print(ls2,res) #['egon', 'yxx'] None

# 方式3末尾删和指定索引删：默认末尾删：列表.pop() 指定索引删：列表.pop(索引)

ls3=['egon','lxx','yxx']

res1=ls3.pop() # 默认是从末尾删除，返回删除的那个值

print(ls3,res1) # ['egon', 'lxx'] yxx

ls4=['egon','lxx','yxx']

res2=ls4.pop(0) # 指定索引删

print(ls4,res2) # ['lxx', 'yxx'] egon

# 方式4清空

ls4=['egon','lxx','yxx']

ls4.clear()

print(ls4) # []

改

#列表[索引] = 要改的值

ls = [1,2,3]

ls[1] = 66666

print(ls) # [1, 66666, 3]

查

#列表[索引]

ls = [1, 2, 3]

print(ls[1]) #

1.列表运算: 得到的是新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]

2.list的长度:len(列表)求列表中的个数

s3 = [3, 4, 1, 2, 5]

print(len(s3)) #

3.切片与字符串的相似：[start_index:end_index:step]》》1.包含初始值，不包含结束值，2.步长为正号正向取，步长为带符号数反向取

s4 = [3, 4, 1, 2, 5]

new_s4 = s4[::-1]

print(new_s4) #[5, 2, 1, 4, 3]

new_s4 = s4[1:4:]

print(new_s4) #[4, 1, 2]

new_s4 = s4[-2:-5:-1]

print(new_s4) #[2, 1, 4]

4.成员运算：in|not in》》注意成员类型例：

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

print('' in s5)   #True

print(1 in s5)     #False

print(5 not in s5) #False

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.增：字典名[key] = 值 => key已存在就是修改值，不存在就是新增值

dic = {'a': 1, 'b': 2}

dic['c'] = 3

print(dic) #{'a': 1, 'b': 2, 'c': 3}

2.删

dic = {'a': 1, 'b': 2}

方式1通用：del[key]

del dic['a']

print(dic) #{'b': 2}

del dic['xxx'] ##key不存在则报错

方式2删除指定key的value并返还删除的value和列表的相似：字典名.pop(k)

res = dic.pop('a')

print(dic,res) #{'b': 2} 1

方式3从dic末尾删除，返还(key, value)形成的元组：字典名.popitem()

res = dic.popitem()

print(dic, res) #{'a': 1} ('b', 2)

方式4清空：字典名.clear()

dic.clear()

3.改

dic = {'a': 1, 'b': 2}

方式1：

dic['b'] = 3

print(dic) #{'a': 1, 'b': 3}

方式2：

dic = {'a': 1, 'c': 2}

d = {'a': 10, 'b': 20}

dic.update(d)

print(dic)  # {'a': 10, 'c': 2, 'b': 20}

方式3 带默认值的新增: 新增key，key已有，啥事不干，没有添加key，值就是第二个参数

dic.setdefault('z', 100)

print(dic)

查：

dic = {'a': 1, 'b': 2}

方式1：字典名[key]

print(dic['c'])  # 只能查找已有的key，没有崩溃

# 有默认值的查询：有key取出对应value，没有返还默认值，默认值可以自定义

print(dic.get('d', 'http://www.baidu.com'))

1.字典的循环：直接循环，就是循环得到key

dic = {'a': 1, 'b': 2}

for k in dic:

     print(k)

2.循环键：字典名.keys（）

print(dic.keys()) #dict_keys(['a', 'b'])

for k in dic.keys():

    print(k) # a,b

3.循环values

print(dic.values()) #dict_values([1, 2])

for v in dic.values():

    print(v) #1,2

4.#同时循环key和value (key, value):字典名.items()

print(dic.items()) #dict_items([('a', 1), ('b', 2)])

# a, b = (1, 2)

# print(a, b)

for res in dic.items():

    print(res) # ('a', 1) ('b', 2)

# 重点

for k, v in dic.items():

    print(k, v) #a 1,b 2

# 空字典

d1 = {}

d2 = dict()

# 用map映射创建字典

d3 = dict({'a': 1, 'b': 1})

print(d3) # {'a': 1, 'b': 1}

# 用关键字赋值方式

d4 = dict(name='Bob', age=18)  # 参数=左侧的名字就是合法的变量名，都会被转化为字符串形式的key

print(d4) #{'name': 'Bob', 'age': 18}

# 创建有多个key值采用默认值的方式: 默认值不写默认None，也可以自定义

d5 = {}.fromkeys('abc', 0)

print(d5) # {'a': 0, 'b': 0, 'c': 0}

元组：可以理解为不可变的列表

# 1.值可以为任意类型

# 2.可以存放多个值 - 可以进行成员运算

# 3.可以存放重复的值 - 可以计算成员出现的次数

# 4.有序存储 - 可以通过索引取值，可以切片

1.索引取值

t1 = (1,2,3,'a','b')

print(t1[1], type(t1[1])) #2 <class 'int'>

print(t1[-3]) #

2.运算(拼接)

print((1, 2) + (2, 3))# (1, 2, 2, 3)

3.长度

print(len(t1))

4.切片

print((2, 1, 3)[::-1])

5.成员运算

print(True in t1)

print(False in t1)  # False == 0， t1中如果有0或False，该结果都是True

6.for循环

for obj in t1:

    print(obj, end=" ")

7.

print(t1.count(0))  # 对象0在元组中出现的次数

print(t1.index(0, 4, len(t1))) # 对象0，在区间4~末尾第一次出现的索引

# 空集合：不能用{},因为用来标示空字典

s = set()

print(s, type(s))

# 概念：

# 1.set为可变类型 - 可增可删

# 2.set为去重存储 - set中不能存放重复数据

# 3.set为无序存储 - 不能索引取值

# 4.set为单列容器 - 没有取值的key

# 总结：set不能取值

# 增

s.add('')

s.add('')

s.add('')

print(s)

s.update({'', ''})

print(s)

# 删

# res = s.pop()

# print(res)

# s.remove('1')

# print(s)

s.clear()

print(s)

# set运算

# 交集：两个都有 &

py = {'a', 'b', 'c', 'egon'}

lx = {'x', 'y', 'z', 'egon'}

print(py & lx)

print(py.intersection(lx))

# 合集：两个的合体 |

print(py | lx)

print(py.union(lx))

# 对称交集：抛出共有的办法的合体 ^

print(py ^ lx)

print(py.symmetric_difference(lx))

# 差集：独有的

print(py - lx)

print(py.difference(lx))

# 比较：前提一定是包含关系

s1 = {'', ''}

s2 = {''}

print(s1 < s2)

1.字符串转化为数字类型
res = int('10')
print(res)
res = int('-3')
print(res)
res = float('.15')
print(res)
res = float('-.15')
print(res)
res = float('-3.15')
print(res)
#注意：需要判断所有能被转换为数字类型的字符串，并转化

2.数字转化字符串
print(str(10))

3.字符串与列表相互转换 ******
s = 'abc123呵呵'
print(list(s)) # ['a', 'b', 'c', '1', '2', '3', '呵', '呵'] 没有对应的 str(ls)
ls = ['a', 'b', 'c', '1', '2', '3', '呵', '呵']
n_s = ''.join(ls)
print(n_s) # 'abc123呵呵'

# s1 = 'a b c 1 2 3 呵 呵'
# res = s1.split() # 默认按空格拆
s1 = 'a b c 1 2 3 呵 呵'
res = s1.split()
print(res)

# 必须掌握
s2 = 'ie=UTF-8&wd=你好帅'
res = s2.split('&')
print(res) # ['ie=UTF-8', 'wd=你好帅']

ls2 = ['ie=UTF-8', 'wd=你好帅']
n_s2 = '@'.join(ls2)
print(n_s2) # ie=UTF-8@wd=你好帅

# 4.需求："ie=UTF-8&wd=你好帅" => [('ie', 'UTF-8'), ('wd', '你好帅')]
res = []
s4 = "ie=UTF-8&wd=你好帅"
ls4 = s4.split('&') # ['ie=UTF-8', 'wd=你好帅']
for ele in ls4: # v = ie=UTF-8 | wd=你好帅
k, v = ele.split('=') # k: ie v: UTF-8
res.append((k, v))
print(res)

# 5.需求："ie=UTF-8&wd=你好帅" => {'ie': 'UTF-8', 'wd': '你好帅'}
res = {}
s5 = "ie=UTF-8&wd=你好帅"
ls5 = s5.split('&') # ['ie=UTF-8', 'wd=你好帅']
for ele in ls5: # v = ie=UTF-8 | wd=你好帅
k, v = ele.split('=') # k: ie v: UTF-8
res[k] = v
print(res)

# 6.需求：[('ie', 'UTF-8'), ('wd', '你好帅')] => {'ie': 'UTF-8', 'wd': '你好帅'}
res = {}
ls6 = [('ie', 'UTF-8'), ('wd', '你好帅')]
for k, v in ls6:
res[k] = v
print(res)

# 7.list与tuple、set直接相互转化 - 直接 类型()

# 8.需求：将汉字转化为数字
# 将 壹、贰、叁、肆、伍、陆、柒、捌、玖、拾、佰、仟
# 转化为 1、2、3、4、5、6、7、8、9、10、100、100
# 作业：壹仟捌佰玖拾叁 => 1893

num_map = {
'壹': 1,
'贰': 2,
'仟': 1000
}
ls8 = ['贰', '壹', '仟']
res = []
for v in ls8:
num = num_map[v] # 通过key去映射表拿到对应的值，完成 '贰' => 2
res.append(num)
print(res)

可变类型:值改变的情况下，id不变 如:列表，字典，集合

不可变类型:值改变的情况下，id也跟着改变

import copy
# 值拷贝：应用场景最多
ls = [1, 'abc', [10]]

ls1 = ls  # ls1直接将ls中存放的地址拿过来
# ls内部的值发生任何变化，ls1都会随之变化

ls2 = ls.copy()  # 新开辟列表空间，但列表中的地址都是直接从ls列表中拿来
# ls内部的可变类型值发生改变，ls2会随之变化

ls3 = copy.deepcopy(ls)  # 新开辟列表空间，ls列表中的不可变类型的地址直接拿过来，但是可变类型的地址一定重新开辟空间
# ls内部的所有类型的值发生改变，ls3都不会随之变化