Python是一个“优雅”、“明确”、“简单”的编程语言,主要流行于网络爬虫、数据分析挖掘、机器学习、人工智能以及运维等等

数字:数字数据类型用于存储数值
字符串:是 Python 中最常用的数据类型
列表:作为一个方括号内的逗号分隔值出现
元组:与列表类似,不同之处在于元组的元素不能修改
字典:是另一种可变容器模型,且可存储任意类型对象
集合:集合(set)是一个无序的不重复元素序列

1.字符串

Python中的可迭代对象有:列表、元组、字典、字符串,常结合for循环使用

  • 不可变数据(3个):Number(数字)、String(字符串)、Tuple(元组)
  • 可变数据(3个):List(列表)、Dictionary(字典)、Set(集合)

zip()函数:将可迭代对象所包含的元素是由原列表元素组成的元组

语法:zip(Iterable1, Iterable2, …)

1
2
3
4
5
6
7
8
a = ["a", "b", "c"]
b = [1, 2, 3]
c = "CHD"
d = [x for x in zip(a,b)]
# [("a", 1, "C"), ("b", 2, "H"), ("c", 3, "D")]
# another way
e = list(zip(a, b))
f = tuple(zip(a, b))

结果为元祖型列表

format():位置参数,参数索引从0开始,format里填写{}对应的参数值

msg = “my name is {}, and age is {}”.format(‘chd’,18)
渲染结果:my name is chd, and age is 18

str.index()字符串索引: 索引值从0开始,不存在就会报错

s=’index’ s[0]=i
s.index(‘i’) = 0 : 查找目标字符串索引值

str.find(‘目标字符串’)查找目标字符串,不存在就返回数值-1(推荐使用find)

“i am iron man”.find(“man”) => 1

移除指定字符串 str.strip()

s = ‘ hello,world! ‘
s.strip()
s.lstrip()
s.rstrip()

len(str)字符串长度

len(‘hello,world’) => 11

str.replace(a,b)替换:在字符串str中,用b来替换a

‘hello,world’.replace(‘o’,’a’) => ‘hella,warld’

str[a:b:c] 切片操作(左闭右开)

[a:b:c]:a表示为索引起始位置(索引以0开始);b表示为索引结束位置;c表示为跳跃间隔
案例如下:

1
2
3
4
5
6
7
8
9
10
11
>>> test="1234hello-world56789"
>>> type(test)
<class 'str'>
>>> test[:]
'1234hello-world56789'
>>> test[0:1]
'1'
>>> test[0:5:2]
'13h'
>>> test[0:5]
'1234h'

string.capitalize()

把字符串的第一个字符大写

str.startswith/endswith(‘目标字符串’)

检查字符串是否以目标字符串开始或结束

str.count(‘目标字符串’):

返回 str 在 string 里面出现的次数

str.join(seq序列):将序列中的元素以指定的字符连接生成一个新的字符串

以指定字符串作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

sequence(序列)是一组有顺序的元素的集合,序列有两种:tuple和list

str.lower()/upper() 将字符串全部转换为小写/大写

“hello world”.lower()/upper() =>”hello world” / “HELLO WORLD”

str.split(指定字符串) 以指定字符串来分割目标字符串,以列表形式返回

1
2
3
4
url = "http://www.baidu.com/python/image/123456.jpg"
#以“.” 进行分隔
path =url.split(".")
path1=['http://www', 'baidu', 'com/python/image/123456', 'jpg']

2019-11-28 新增:
当split的参数为空时,即string.split():表示以空格作为分割符,并将换行符也去掉

2.列表

列表截取(索引从0开始,且满足左闭右开原则)与拼接:从右至左取值,则索引默认从-1开始

1
2
3
L = ['Google', 'Runoob', 'Taobao']
# L[2]='Taobao' L[-1]='Taobao'
# L[0:2] = ['Google', 'Runoob']

列表函数和方法

函数和方法 描述
len(list) 列表元素个数
list(seq) 将元组或字符串转换为列表
max/min(list) 返回列表元素最大/最小值
list.append(obj) 在列表末尾添加新的对象
list.count(obj) 统计某个元素在列表中出现的次数
list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj) 将对象插入列表
list.pop([index=n]) 移除指定索引的元素值(默认最后一个元素),并且返回该元素的值
list.remove(obj) 移除列表中某个值的第一个匹配项
list.reverse() 反向列表中元素
list.sort( key=None, reverse=False) 对原列表进行排序

常见案例:列表拆分,列表破开
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 将obj数组分割成每100个一组
numbers=[1,2,3,4,5,6,7,8,...,10000]
number =[]
for i in range(0, len(numbers), 100):
number.append(numbers[i:i + 100])

# 列表破开平叠(递归)
def flatten(arr):
res = []
for i in arr:
if isinstance(i, list):
# 递归破开数组
res.extend(flatten(i))
else:
res.append(i)
return res

target_list = [[12, 5, 6], 2, 6, [13], [66, [[1, 0]]], 99]
result = flatten(arr=target_list)
# [12, 5, 6, 2, 6, 13, 66, 1, 0, 99]

列表的list.remove(obj)使用说明:
移除列表的指定的某一项(PS:不是索引,是具体的值)

a = [1,2,3,8,10,56,110]
c = a.remove(8) (c为None)
    👇
a = [1, 2, 3, 10, 56, 110]
----------------------------
a = [1,2,3,8,10,56,110]
b = a.pop(3) (b为8,pop返回该元素的值) 
    👇
a = [1, 2, 3, 10, 56, 110]

2021-04-28 新增:列表排序汇总
sort与sorted方法区别:

  • 列表的sort方法在执行后,会需要改源列表
  • sort()是列表的私有方法,是只能对列表使用
  • sorted()是Python的内置方法,适用于所有的可迭代对象,且会返回新列表,不修改源列表
  1. 修改原列表,不创建新列表的方法
1
2
3
4
5
6
7
8
a = [3, 2, 8, 4, 6]
print(id(a)) # 2180873605704
a.sort() # 默认升序
print(a) # [2, 3, 4, 6, 8]
print(id(a)) # 2180873605704

a.sort(reverse=True)
print(a) # [8, 6, 4, 3, 2]
  1. 创建新列表的排序

通过内置函数sorted(iterable, cmp=None, key=None, reverse=False)进行排序,这个方法返回新列表,不对原列表做修改

1
2
3
4
5
a = [3, 2, 8, 4, 6]
b = sorted(a) # 默认升序
c = sorted(a, reverse=True) # 降序
print(b) # [2, 3, 4, 6, 8]
print(c) # [8, 6, 4, 3, 2]

3.元组

3.1元组的创建

元组使用小括号,而列表使用方括号,只需要在括号中添加元素,并使用逗号隔开即可

1
tup1 = ('a','b','c',336)

3.2 元组的访问使用下脚标索引来访问元组中的值,下标索引从0开始

tup1[0] => 'a' ,tup[1] => 'b'

3.3 元组的修改

元组中的元素是不允许修改或删除的,但我们可以使用+对其进行拼接组合
tuple(seq):将列表转换为元组。

4.字典

4.1字典的创建

字典的每个键值 key=>value 对用冒号 : 分割,每个键值对之间用逗号  ,  分割,整个字典包括在花括号 {}

1
d = {key1 : value1, key2 : value2 }

值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组

1
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258',9527:'badwoman',6394:998}

4.2 字典的访问

访问方式:
字典名["键名"] 或者
字典名.get("键名",自定义数据):当目标键名不存在时,使用自定义数据值作为默认值,注意此刻不会修改原字典

4.3 字典的更新

1
2
3
4
5
6
7
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

dict['Age'] = 8 # 更新
dict['School'] = "RUNOOB" # 添加

print("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])

4.4 内置函数和方法

函数和方法 描述
len(dict) 计算字典元素个数,即键的总数
key [not] in dict 键在字典里返回true,否则返回false
dict.keys() 获取包含字典所有的key的列表
dict.values() 获取包含字典所有的value的列表
dict.items() 将字典的键值一一对应组合成一个元组,以列表的形式返回值
dict1.update(dict2) 合并字典,将dict2合并至dict1,键名相同时,会覆盖原值
dict.pop(key) 删除字典给定键key所对应的值,返回值为被删除的值,key不可为空

拓:Python遍历字典,获得字典键、值的函数有:items/ iteritems/ keys/ iterkeys/ values/ itervalues

  1. 通常情况下较常用,效率也能满足一般需要
1
2
3
4
a_dict = {" name": "sir", "lang": "python", "email": "sir@ gmail.com"}

for k in a_dict():
print k, a_dict[k]
  1. items,iteritems
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 for k, v in a_dict.items(): 
print k, v

lang python
website www.it.com
name sir email sir@ gmail.com


for k, v in a_dict.iteritems():
print k, v

demo={'Name': 'Zara', 'Age': 8, 'Class': 'First', 'School': 'RUNOOB'}
demo.items()
# dict_items([('Name', 'Zara'), ('Age', 8), ('Class', 'First'), ('School', 'RUNOOB')])

a = [x for x in demo.items()]
print(a) # a=[('Name', 'Zara'), ('Age', 8), ('Class', 'First'), ('School', 'RUNOOB')]

以 上 两 种 方 法 也 能 够 实 现 同 样 的 效 果, 特 别 是 第 二 个 iteritems() 效 率 挺 高

  1. keys: 效果跟前面一样,但不太提倡,因为效率比较低。
1
2
3
4
5
6
7
for k in a_dict.keys():
print k, a_dict[k]

lang python
website www.it.com
name sir
email sir@ gmail.com

5.Number

Python3 支持 int、float、bool、complex(复数)等数字类型。
对数字类型常见的操作为:

  • 数字类型转换:int(x),float(x),complex(x,y)表示将x转换为相应的数据类型
  • 数学函数运算:abs,exp,log,sqrt,round
  • 随机数函数:choice,randrange ([start,] stop [,step]),random,shuffle
  • 三角函数:sin,cos,tan
  • 数学常量:pi,e

6.集合

集合set是一个无序的不重复的序列,可以使用大括号{}或者set()函数创建集合。创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典

创建格式:

1
2
3
4
5
6
7
8
9
10
11
12
param = {'apple','orange','pear'}
或者
set(("Google", "Runoob", "Taobao"))

因为集合的不重复性,也可用来去重:
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange'}
>>> print(basket) # 这里演示的是去重功能
{'orange', 'pear', 'apple'}
>>> 'orange' in basket # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

集合的基本操作:

  1. add():添加元素到集合中,如元素已存在,不进行任何操作
  2. remove():将目标元素移出集合中
  3. pop():随机删除集合中的一个元素
  4. len():计算集合的元素个数
  5. in:判断元素是否在集合中存在
  6. 集合之间的运算(并集,交集,补集)
1
2
3
4
5
6
7
8
9
10
11
12
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

7.直接赋值,浅拷贝和深拷贝

  • 直接赋值:其实就是对象的引用(别名)。

  • 浅拷贝(copy):拷贝父对象,不会拷贝对象的内部的子对象。

  • 深拷贝(deepcopy): copy 模块的 deepcopy 方法,完全拷贝了父对象及其子对象。

解析:

  1. b = a 赋值引用,a与b都指向同一个对象,即共有同一块内存地址
1
2
3
4
5
6
a = {1: [1, 2, 3]}
b = a # b = {1: [1, 2, 3]}
# 更新a的值
a[1]=[1,2,3,4]
print(b) # b = {1: [1, 2, 3, 4]}
# 即直接赋值也属于浅拷贝,共用同样一块地址
  1. b = a.copy():浅拷贝,a与b是一个独立的对象,但他们的子对象还是指向统一对象(是引用)
1
2
3
4
5
a = {1: [1,2,3]}
b = a.copy()
print(a,b) # ({1: [1, 2, 3]}, {1: [1, 2, 3]})
a[1].append(4) # 字典更新
print(a, b) #({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]})
  1. b = copy.deepcopy(a) 深拷贝:深度拷贝, a 和 b 完全拷贝了父对象及其子对象,两者是完全独立的,是两块独立的地址。
1
2
3
4
5
6
7
>>> import copy
>>> c = copy.deepcopy(a)
>>> a, c
({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]})
>>> a[1].append(5)
>>> a, c
({1: [1, 2, 3, 4, 5]}, {1: [1, 2, 3, 4]})

8.map与reduce函数

  • map

map()函数接收两个参数,一个是函数,一个是Iterable(可迭代对象),map将传入的函数依次作用到序列的每个元素,并把结果作为新的Iterator(迭代器)返回(可以使用list转换为数组),而python2返回的是一个数组

1
2
3
4
5
def f(x):
return x * x

r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
list(r) # [1, 4, 9, 16, 25, 36, 49, 64, 81]

Python3使用map返回结果是迭代器,需要使用list将其转换为列表

  • reduce

reduce把一个函数作用在一个序列[x1, x2, x3, …]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算,其效果就是

1
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

比方说对一个序列求和,就可以用reduce实现:

1
2
3
4
5
6
>>> from functools import reduce
>>> def add(x, y):
... return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25
  • filter

filter()也接收一个函数和一个序列。从一个序列中筛出符合条件的元素。和map()不同的是,filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素

1
2
3
4
5
6
7
8
# 获取列表内所有的整数类型元素
def only_int(x):
if isinstance(x, int):
return True
else:
return False
dt = filter(only_int, [1, 2, 3, 3, '3232', -34.5, 34.5])
print(list(dt)) # [1, 2, 3, 3]

9.Python的遍历技巧

  • 在字典中遍历时,关键字和对应的值使用item()方法同时解读出来

knights = {‘name’: ‘chd’, ‘age’: 18 } for k, v in knights.items():

  • 枚举函数,在序列遍历时,索引值和对应值使用enumerate()函数得到

for i, v in enumerate([‘tic’, ‘tac’, ‘toe’]):

  • zip()函数:同时遍历两个或更多的序列

参考文章


 评论

联系我 | Contact with me

Copyright © 2019-2020 谁知你知我,我知你知深。此恨经年深,比情度日久

博客内容遵循 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 协议