Python脱产8期 Day05 2019/4/17

数字类型

# 了了解：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也跟着改变

值拷贝与深浅拷贝

链接：https://www.cnblogs.com/zuanzuan/p/10185075.html

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都不会随之变化