list的两个方法 append() 和 extend()
L.append(object)
# 将对象追加到列表的末尾、
# 将对象当作唯一元素追加到列表末尾
# 直接操作原list对象、无返回值
# append方法每次操作 列表长度加1
[1, 2, 3, 4, 5, [6, 7, 8, 9, 0]]
L.extend(iterable)
# 通过附加iterable中的元素来扩展列表、
# 将可迭代对象中的元素当作单个元素依次追加到列表末尾
# 直接操作原list对象、无返回值
# extend方法每次操作 列表长度增加可迭代对象的长度
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
# map(function, iterable, ...) Return an iterator 将function应用于iterable的每个项目，产生结果.如果map有多个iterable参数，则function函数同样也需要多个参数.使用多个iterables时，迭代器会在最短的iterable耗尽时停止. """
map(lambda x:x**2,[1,2,3,4]) # 产生一个迭代器，而不是list，
map(lambda x,y:x+y,[1,2,3,4],[2,4,6,8,10])
# filter(function, iterable) |function -- 判断函数 | iterable -- 可迭代对象 | filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表 | 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中 """
# -*- coding: UTF-8 -*-
def is_odd(n): # 返回奇数
return n % 2 == 1
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist) # [1, 3, 5, 7, 9]
# reduce() 函数会对参数序列中元素进行累积 python3中取消了全局命名空间中的reduce()函数，将reduced()放到了functools模块中，要使用reduce()的话，要先加载functools. """
from functools import reduce
print(reduce(lambda x, y: x + y, [1, 3, 4, 6, 8]))
# zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。(实际返回的是迭代器对象， 需要使用list()方法进行list化)
L=['name','age','country','sex','birth']
ZL = zip(L)
print(list(ZL)) # [('name',), ('age',), ('country',), ('sex',), ('birth',)]
# namedtuple类位于collections模块,有了namedtuple后可以通过属性访问数据 | namedtuple能够用来创建类似于元祖的数据类型，除了能够用索引来访问数据，能够迭代，还能够方便的通过属性名来访问数据。 | 传统的tuple类似于数组，只能通过下标来访问各个元素，我们还需要注释每个下表代表什么数据。"""
from collections import namedtuple
Request = namedtuple("Request",['url','method','data'])
req = Request('http://www.baidu.com', 'GET', 'wd=namedtuple')
print(req.url, req.method, req.data)
"""
==UserDict ==
collections模块的UserDict包含了一个可继承的字典类 (事实上是对内建字典类型的 Python 封装).
展示了一个增强的字典类, 允许对字典使用 "加/+"
操作并提供了接受关键字参数的构造函数.
"""
from collections import UserDict
class FancyDict(UserDict):
def __init__(self, data = {}, **kw):
UserDict.__init__(self)
self.update(data)
self.update(kw)
def __add__(self, other):
dict = FancyDict(self.data)
dict.update(b)
return dict
a = FancyDict(a = 1)
b = FancyDict(b = 2)
print( a + b)
# 可变参数args类型为tuple类型，关键字参数kwargs为dict类型
def A(*args,**kwargs):
print(type(args)) # <class 'tuple'>
print(type(kwargs)) # <class 'dict'>
A()
条件表达式的常见用途是选择变量赋值. True if condition else False
条件表达式的优先级低于几乎所有其他运算符，因此需要使用括号将其自身分组。z = (1 + x) if x > y else (y + 2)
lambda 表达式本质式一个匿名函数, 返回的也是一个函数, 直接使用,让返回值时,记得要先调用哦
例如：a = lambda x,y : x+y # a指代函数, a(1,2)调用
例如：def test(x,y): return (lambda x,y :x+y)(x,y) # 直接返回
lambda+三元运算: a = lambda x,y: x if x>y else y
# -*- coding:utf-8 -*-
import json
# pickle 非常有用的库,后续研究
# json.dumps 将一个Python数据结构转换为JSON
data = {
'name' : 'ACME',
'shares' : 100,
'price' : 525.05
}
json_str = json.dumps(data)
# {"name": "ACME", "shares": 100, "price": 542.23}
# json.loads 将一个JSON编码的字符串转换回一个Python数据结构'
datas = json.loads(json_str)
'如果你要处理的是文件而不是字符串，你可以使用 json.dump() 和 json.load() 来编码和解码JSON数据'
# json.dump writing JSON data to file
with open('data.json', 'w') as f:
json.dump(data, f)
# json.load reading data back
with open('data.json', 'r') as f:
data = json.load(f)
print(data)
# 装饰器代码
def A(fn):
def wrapper(*args,**kw):
print("call %s(): method" %fn.__name__)
return fn(*args,**kw)
return wrapper
@A
def functionB(a,b):
x = lambda a,b : a if a>b else b
print("%d 和 %d 最大数是 %d" %(a,b,x(a,b)))
functionB(1,2)
#====================================
# -*- coding:utf-8 -*-
def cmp(a,b):
if (lambda a,b:True if str(a).isdigit() and str(b).isdigit() else False)(a,b):
return a if a>b else b
else:
print("参数错误,重新输入")
print(cmp(11,2))
#========================================
# -*- coding: utf8 -*-
# 列表相关操作
# Python 必会知识
#列表 元组 字典 集合
'''
增加 append()
删除 del list[0]
修改
查询 list[0] list[:-1] list[:] list[1:4]
遍历 for I in list: print(i)
截取 list[1:]
长度 len(list)
组合 list1_+ist2
重复 list1*4
元素是否存在于列表中 1 in range(0,10)
迭代 for I in list: print(i)
比较 cmp(L1,L2)
最大值 max(list)
最小值 min(list)
元组转换列表 list(tuple)
'''
list = [12,22,24,26,28,30]
#列表追加元素
list.append(obj)
#统计某个元素出现个数
list.count(obj)
#列表末尾追加序列seq
list.extend(seq)
#列表中元素的索引获取
list.index(obj)
#对象插入列表
list.insert(index,obj)
#移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值
list.pop(index = -1)
#移除列表中某个值的第一个匹配值
list.remove(obj)
#反向列表中的元素
list.reverse()
#对原列表进行排序
list.sort()
'''
Python的元组与列表类似，不同之处在于元组的元素不能修改.
<1> 元组使用小括号，列表使用方括号.
<2> 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可.
<3> 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合.
<4> 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组.
<5> 元组可以使用下标索引来访问元组中的值.
'''
alphabet = ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z')
# 比较两个元组元素
cmp(tuple1,tuple2)
# 计算元组元素个数
len(tuple1, tuple2)
# 返回元组中元素最大值
max(tuple)
# 返回元组中元素最小值
min(tuple)
# 将列表转换为元组
tuple(seq)
# -*- coding:utf-8 -*-
# set 是一个无序不重复元素的序列
# 可以使用大括号 { } 或者 set() 函数创建集合
# 注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
# TypeError: 'set' object does not support indexing
# TypeError: set expected at most 1 arguments, got 2
# TypeError: 'int' object is not iterable 不能给set通过update添加不能迭代的对象
# 创建空集合
set_e = set()
# 创建个位数字集合
set1 = set(range(0,9))
set2 = {0,1,2,3,4,5,6,7,8,9}
set3 = { int(i) for i in range(0,9)}
# 创建字母集合
set_a = {chr(i) for i in range(97, 123)}
# 创建其他集合
name = {'java','python','lua','node'}
abc = {1,'a','best','last',"china",True}
# 添加集合set元素
# add添加一项
# update添加多项
s = set()
s.add(1)
s.update(range(0,10)) # 将可迭代的列表添加到集合中
s.update((12,22,32,42)) # 将可迭代的元组添加到集合中
s.update({110,120,119}) # 将可迭代的集合添加到集合中
# 删除集合set元素
s.remove('a')
s.discard(110)
# 随机删除集合中的一个元素
s.pop()
# 计算集合元素个数
len(s)
# 清空集合
s.clear()
# 判断元素是否在集合中存在
isExist = 5 in s
# 集合相关操作
s1 = {int(i) for i in range(0,10)}
s2 = {2,4,6,8,10,12}
# 交集
x1 = s1&s2
x2 = s1.intersection(s2)
# 并集
y1 = s1|s2
y2 = s1.union(s2)
# 差集
z1 = s1-s2
z2 = s1.difference(s2)
# 子集
s3 = {2,3,4}
print (s3.issubset(s1)) # True s3是s1的子集
print (s2.issubset(s1)) #False s2不是s1的子集
# 父集
print (s1.issuperset(s3)) #True
print (s1.issuperset(s2)) #False
# 对称差集--元素只属于其中一个集合
print (s1.symmetric_difference(s3))
print (s1^s3)
# 判断两个集合是否无交集
s4 = {11,12,13,14}
print (s1.isdisjoint(s4)) # True
import unittest
import requests
# unittest
unittest # 单元测试框架, 有许多的断言测试方法
unittest.TestCase # 实例是单个测试用例
unittest.TestSuite # 测试套件是由许多测试用例组成的复合测试
unittest.TextTestRunner # 测试运行类，以文本形式显示结果
unittest.TextTestResult # 测试结果类，用来处理测试用例或测试集执行过程中的所有信息并最终输出
unittest.TextTestRunner().run("test case | test suite") # Run the given test case or test suite
#requests
'requests 是一个用Python编写的HTTP库，供人类使用'
requests.head(url, **kwargs)
requests.get(url, params=None, **kwargs)
requests.post(url, data=None, json=None, **kwargs)
requests.put(url, data=None, **kwargs)
requests.patch(url, data=None, **kwargs)
requests.delete(url, **kwargs)
requests.request(method, url, **kwargs)
#requests.Session.request 所有请求方法都最终通过这个方法实现的哦
def request(self, method, url,
params=None, data=None, headers=None, cookies=None, files=None,
auth=None, timeout=None, allow_redirects=True, proxies=None,
hooks=None, stream=None, verify=None, cert=None, json=None):
pass
- Python的字符串类型
"""Python2.x"""
# 1.str表示8位文本和二进制数据
# 2.unicode表示宽字符Unicode文本
"""Python3.x"""
# 1.str表示Unicode文本（8位或者更宽）
# 2.bytes表示不可变的二进制数据
# 3.bytearray是一种可变的bytes类型
- 字符编码方法
"""ASCII""" # 一个字节，只包含英文字符，0到127，共128个字符，利用函数可以进行字符和数字的相互转换
ord('a') # 字符a的ASCII码为97，所以这里返回97
chr(97) # 和上边的过程相反，返回字符'a'
"""Latin-1""" # 一个字节，包含特殊字符，0到255，共256个字符，相当于对ASCII码的扩展
chr(196) # 返回一个特殊字符：Ä
"""Unicode""" # 宽字符，一个字符包含多个字节，一般用于亚洲的字符集，比如中文有好几万字
"""UTF-8""" # 可变字节数，小于128的字符表示为单个字节，128到0X7FF之间的代码转换为两个字节，0X7FF以上的代码转换为3或4个字节
# 注意：可以看出来，ASCII码是Latin-1和UTF-8的一个子集
# 注意：utf-8是unicode的一种实现方式，unicode、gbk、gb2312是编码字符集
- 查看Python中的字符串编码名称，查看系统的编码
import encodings
help(encoding)
import sys
sys.platform # 'win64'
sys.getdefaultencoding() # 'utf-8'
sys.getdefaultencoding() # 返回当前系统平台的编码类型
sys.getsizeof(object) # 返回object占有的bytes的大小
- 源文件字符集编码声明: 添加注释来指定想要的编码形式 从而改变默认值 注释必须出现在脚本的第一行或者第二行
"""说明：其实这里只会检查#和coding:utf-8，其余的字符都是为了美观加上的"""
# _*_ coding: utf-8 _*_
# coding = utf-8
编码: 字符串 --> 原始字节 #解码: 原始字节 --> 字符串
- Python3.x中的字符串应用
s = '...' # 构建一个str对象，不可变对象
b = b'...' # 构建一个bytes对象，不可变对象
s[0], b[0] # 返回('.', 113)
s[1:], b[1:] # 返回('..', b'..')
B = B"""
xxxx
yyyy
"""
# B = b'\nxxxx\nyyyy\n'
# 编码，将str字符串转化为其raw bytes形式：
str.encode(encoding = 'utf-8', errors = 'strict')
bytes(str, encoding)
# 编码例子：
S = 'egg'
S.encode() # b'egg'
bytes(S, encoding = 'ascii') # b'egg'
# 解码，将raw bytes字符串转化为str形式：
bytes.decode(encoding = 'utf-8', errors = 'strict')
str(bytes_or_buffer[, encoding[, errors]])
# 解码例子：
B = b'spam'
B.decode() # 'spam'
str(B) # "b'spam'"，不带编码的str调用，结果为打印该bytes对象
str(B, encoding = 'ascii')# 'spam'，带编码的str调用，结果为转化该bytes对象
- Python2.x的编码问题
u = u'汉'
print repr(u) # u'\xba\xba'
s = u.encode('UTF-8')
print repr(s) # '\xc2\xba\xc2\xba'
u2 = s.decode('UTF-8')
print repr(u2) # u'\xba\xba'
# 对unicode进行解码是错误的
s2 = u.decode('UTF-8') # UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)
# 同样，对str进行编码也是错误的
u2 = s.encode('UTF-8') # UnicodeDecodeError: 'ascii' codec can't decode byte 0xc2 in position 0: ordinal not in range(128)
- bytes对象
B = b'abc'
B = bytes('abc', 'ascii')
B = bytes([97, 98, 99])
B = 'abc'.encode()
# bytes对象的方法调用基本和str类型一致 但:B[0]返回的是ASCII码值97, 而不是b'a'
- 文本文件: 根据Unicode编码来解释文件内容，要么是平台的默认编码，要么是指定的编码类型
# 二进制文件：表示字节值的整数的一个序列 open('bin.txt', 'rb')
- Unicode文件
s = 'A\xc4B\xe8C' # s = 'A?BèC' len(s) = 5
#手动编码
l = s.encode('latin-1') # l = b'A\xc4B\xe8C' len(l) = 5
u = s.encode('utf-8') # u = b'A\xc3\x84B\xc3\xa8C' len(u) = 7
#文件输出编码
open('latindata', 'w', encoding = 'latin-1').write(s)
l = open('latindata', 'rb').read() # l = b'A\xc4B\xe8C' len(l) = 5
open('uft8data', 'w', encoding = 'utf-8').write(s)
u = open('uft8data', 'rb').read() # u = b'A\xc3\x84B\xc3\xa8C' len(u) = 7
#文件输入编码
s = open('latindata', 'r', encoding = 'latin-1').read() # s = 'A?BèC' len(s) = 5
s = open('latindata', 'rb').read().decode('latin-1') # s = 'A?BèC' len(s) = 5
s = open('utf8data', 'r', encoding = 'utf-8').read() # s = 'A?BèC' len(s) = 5
s = open('utf8data', 'rb').read().decode('utf-8') # s = 'A?BèC' len(s) = 5
- Python实现任意深度的赋值 例如a[0] = 'value1'; a[1][2] = 'value2'; a[3][4][5] = 'value3'
class MyDict(dict):
def __setitem__(self, key, value): # 该函数不做任何改动 这里只是为了输出
print('setitem:', key, value, self)
super().__setitem__(key, value)
def __getitem__(self, item): # 主要技巧在该函数
print('getitem:', item, self) # 输出信息
# 基本思路: a[1][2]赋值时 需要先取出a[1] 然后给a[1]的[2]赋值
if item not in self: # 如果a[1]不存在 则需要新建一个dict 并使得a[1] = dict
temp = MyDict() # 新建的dict: temp
super().__setitem__(item, temp) # 赋值a[1] = temp
return temp # 返回temp 使得temp[2] = value有效
return super().__getitem__(item) # 如果a[1]存在 则直接返回a[1]
# 例子:
test = MyDict()
test[0] = 'test'
print(test[0])
test[1][2] = 'test1'
print(test[1][2])
test[1][3] = 'test2'
print(test[1][3])
- Python中的多维数组
lists = [0] * 3 # 扩展list，结果为[0, 0, 0]
lists = [[]] * 3 # 多维数组，结果为[[], [], []]，但有问题，往下看
lists[0].append(3) # 期望看到的结果[[3], [], []]，实际结果[[3], [3], [3]]，原因：list*n操作，是浅拷贝，如何避免？往下看
lists = [[] for i in range(3)] # 多维数组，结果为[[], [], []]
lists[0].append(3) # 结果为[[3], [], []]
lists[1].append(6) # 结果为[[3], [6], []]
lists[2].append(9) # 结果为[[3], [6], [9]]
lists = [[[] for j in range(4)] for i in range(3)] # 3行4列，且每一个元素为[]
网友评论