	tuple	list	dict	set
形式	a = (1,2,3)	a = [1,2,3]	a ={"x": 1,"y":2}	a ={1,2,3}
特点	长度固定无法对元素进行增删改查存储空间小性能优	长度不固定可以对元素进行增删改查存储空间比元组大（由于动态，需要存储指针）性能比元组差	通过索引键访问性能高内部结构是哈希表	不支持索引访问性能高内部结构是哈希表
互相转换	tuple()	list()
常用函数	计算item出现的次数：count(item) 计算item第一次出现的index：index(item) 元素反转：reversed(tuple) 排序：sorted(tuple)	计算item出现的次数：count(item) 计算item第一次出现的index：index(item) 元素反转：reverse() 排序：sort()	增加键值对：a['z'] = "2" 删除键值对：a.pop('x')，注意pop是删除字典中的最后一个元素，而字典是无序的，所以不知道会删除谁	增加元素：a.add(item) 删除元素：a.remove(item) 排序：sorted(set)

list和str互相转换

1、list转str

''.join(list)

eg：

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

''.join(list) 结果即为：12345

','.join(list) 结果即为：1,2,3,4,5

2、str转list

str.split(',')
list(str)

str转tuple

stra= “ell,sdsfd,sdfd”

listb = stra.split(',')

tuplec = tuple(listb)

字符串

python字符串支持三种引号的表达式，'、"、"""，三种表达式的值完全一样，方便在字符串中嵌套引号

字符串格式化

方式

f''

str.format()

用法举例

name = ’ABC‘

f’hello {name}'--->hello ABC
F'My name is {name.lower()}' --->My name is abc
f'result is {(lambda x: x ** 2 + 1) (2)}'

name = “ABC”

print("hello {}" .format(name))--->hello ABC
print('{0} {1} {0}'.format('hello','world'))---> hello world hello
print('{name}.format(name))---> ABC

name = “ABC”

print("hello %s！" %(name))--->hello ABC

说明

f-string，亦称为格式化字符串常量（formatted string literals），是Python3.6新引入的一种字符串格式化方法
性能优于str.format()

字典

遍历字典中的key、value

for k,v in dict.items():
print(k,v)

循环

for

while

特点

性能>while

需要在满足某个条件前，不停地重复某些操作，并且没有特定的集合需要去遍历，一般用 while 循环

说明

for item in iterable:
if condition:
expression1
else:
expression2

可简写成：
expression1 if condition else expression2 for item in iterable

self

self指的是类实例对象本身
类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。
self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定是用 self。
如果变量前面加了self，那么在任何实例方法（非staticmethod和calssmethod）就都可以访问这个变量

with

作用：使用了 with 语句，就不需要显式调用 close()。在 with 的语境下任务执行完毕后，close() 函数会被自动调用。

函数

不定长参数

不知道函数会传递多少个参数时可使用*args, **kwargs

eg：def wrapper(*args, **kwargs):

	*args	**kwargs
说明	发送一个非键值对的可变数量的参数列表给一个函数	将不定长度的键值对作为参数传递给一个函数
举例	`def test_args(first, *args): print('Required argument: ', first) print(type(args)) for v in args: print ('Optional argument: ', v) test_args(1, 2, 3, 4) ----> Required argument: 1 <class 'tuple'> Optional argument: 2 Optional argument: 3 Optional argument: 4`	`def test_kwargs(first, args, *kwargs): print('Required argument: ', first) print(type(kwargs)) for v in args: print ('Optional argument (args): ', v) for k, v in kwargs.items(): print ('Optional argument %s (kwargs): %s' % (k, v)) test_kwargs(1, 2, 3, 4, k1=5, k2=6) ----> Required argument: 1 <class 'dict'> Optional argument (args): 2 Optional argument (args): 3 Optional argument (args): 4 Optional argument k2 (kwargs): 6 Optional argument k1 (kwargs): 5`
其他	kwargs 是 keyword arguments args 是 arguments 的缩写 args 必须放在 kwargs 的前面和 ** 表示解包 eg：元组解包后传给对应的实参 `def test_args_kwargs(arg1, arg2, arg3): print("arg1:", arg1) print("arg2:", arg2) print("arg3:", arg3) args = ("two", 3, 5) test_args_kwargs(*args) #result: arg1: two arg2: 3 arg3: 5`

内建函数

zip()

作用：

将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
利用 * 号操作符，可以将元组解压为列表。

举例：

a = [1,2,3]

c = [4,5,6,7,8]

zipped = zip(a,c) 

----->zipped = [(1, 4), (2, 5), (3, 6)]       #元素个数=最短列表个数

zip(*zipped) 

----->[(1, 2, 3), (4, 5, 6)]            #*反解压

isinstance()

作用：判断类型

eg：

判断是否为datetime类型：

isinstance(timeInput, datetime.datetime)

自定义函数

def 是可执行语句，这意味着函数直到被调用前，都是不存在的。当程序调用函数时，def 语句才会创建一个新的函数对象，并赋予其名字。
主程序调用函数时，必须保证这个函数此前已经定义过。而在函数内部调用其他函数，函数间哪个声明在前、哪个在后就无所谓，因为 def 是可执行语句，函数在调用之前都不存在。
函数的参数可以设定默认值。def func(param = 0):
Python 函数的另一大特性，支持函数的嵌套，指函数里面又有函数。

函数的嵌套能够保证内部函数的隐私。内部函数只能被外部函数所调用和访问，不会暴露在全局作用域。

合理的使用函数嵌套，能够提高程序的运行效率

嵌套函数中的内部函数可以访问外部函数定义的变量，但是无法修改，若要修改，必须加上 nonlocal 这个关键字

在函数内部改变全局变量的值，必须加上 global 这个声明，告诉 Python 解释器，函数内部的变量就是之前定义的全局变量
闭包函数：闭包和嵌套函数类似，不同的是，闭包的外部函数返回的是一个函数，而不是一个具体的值

举例：

def nth_power(exponent):
    def exponent_of(base):
        return base ** exponent
    return exponent_of # 返回值是exponent_of函数

square = nth_power(2) # 计算一个数的平方
cube = nth_power(3) # 计算一个数的立方 
print(square(2))  # 计算2的平方
print(cube(2)) # 计算2的立方
# 输出
4 # 2^2
8 # 2^3

匿名函数

	匿名函数 lambda	常规函数 def
特点	lambda 专注于简单的任务 lambda 的主体是只有一行的简单表达式，并不能扩展成一个多行的代码块。	常规函数则负责更复杂的多行逻辑
	匿名函数是个表达式，不是语句 lambda 可以用在列表内部 lambda 可作为函数的参数	不能用在列表内部不能作为函数的参数
	匿名函数在调用前无须被定义	先定义函数才能调用函数（def 必须通过其函数名被调用）
优点	简化代码复杂度
使用场景	函数内容非常简短，只需要一行就能完成在程序中只被调用一次	函数内容复杂需多次调用

面向对象

类

对象

属性

函数

说明

一群有着相似性的事物的集合

集合中的一个事物

由 class 生成的某一个 object

对象的某个静态特征

对象的某个动态能力

	静态方法	类方法	成员方法
装饰器	@staticmethod	@classmethod	无
特点	通过类直接调用，不需要创建对象，不会隐式传递self 代码可读性好：看到该标签就知道这个方法并不需要依赖对象本身的状态。节省内存空间，既然是与类实例无关自然就不用创建类实例对象。相当于一个相对独立的方法，跟类没有什么关系，只是在类的作用域里的函数而已	至少需要一个cls参数类方法只能操作类本身的公有字段类成员方法无法访问实例变量但是可以访问类变量	第一个参数 self 代表当前对象的引用，可以通过此函数，来实现想要的查询 / 修改类的属性等功能。
适用场景	在方法中不需要访问任何实例方法和属性，纯粹地通过传入参数并返回数据的功能性方法，那么它就适合用静态方法来定义	实现不同的 init 构造函数

init

init表示构造函数，即一个对象生成时会被自动调用的函数。

私有属性

属性以 __ （注意，此处有两个 _）开头，则为私有属性，不能在类的函数之外的地方被访问和修改。

继承

每个类都有构造函数，继承类在生成对象的时候，是不会自动调用父类的构造函数的，因此你必须在 init() 函数中显式调用父类的构造函数。它们的执行顺序是子类的构造函数 -> 父类的构造函数。

抽象类

抽象类是一种特殊的类，它生下来就是作为父类存在的，一旦对象化就会报错。同样，抽象函数定义在抽象类之中，子类必须重写该函数才能使用。相应的抽象函数，则是使用装饰器 @abstractmethod 来表示。

时间

获取当前时间的秒格式时间戳

import time

int(time.time())

pytz

是什么：pytz是python的时区模块，常用于时区的转换

怎么用：常常配合datetime一起使用

datetime除了data方法生成的时间是没有时区概念，其他如time、datetime等都是有时区概念

其提供的对象方法为：

__all__ = [
    'timezone', 'utc', 'country_timezones', 'country_names',
    'AmbiguousTimeError', 'InvalidTimeError',
    'NonExistentTimeError', 'UnknownTimeZoneError',
    'all_timezones', 'all_timezones_set',
    'common_timezones', 'common_timezones_set',
]

eg：（更多参考：https://segmentfault.com/a/1190000019697169）

timezone:传入一个时区,如:Asia/Shanghai,返回一个时区对象

pytz.timezone('Asia/Shanghai')
>>> <DstTzInfo 'Asia/Shanghai' LMT+8:06:00 STD>

utc: 返回一个utc时区对象

pytz.utc
>>> <UTC>

eg:

# 秒格式时间戳转换成日期格式
def timestampToDate1(timestamp):
    timestamp_int = int(timestamp)
    tz = pytz.timezone(TIME_ZONE)
    dt = pytz.datetime.datetime.fromtimestamp(timestamp_int, tz)
    otherStyleTime = dt.strftime("%Y-%m-%d %H:%M:%S")
    return otherStyleTime

json

json.loads()/json.dumps()

json.loads()

json.dumps()

说明

将字符串反序列化为字典类型

将字典序列化为 string类型

举例

import json

a='{"errno":0,"errmsg":null,"unassigned":0,"total":0,"list":null}'

a1=json.loads(a)

-->a1={'errno':0,'errmsg':None,'unassigned':0,'total':0,'list':None}

import json

a='{"errno":0,"errmsg":null,"unassigned":0,"total":0,"list":null}'

a2=json.dumps(a)

-->a2="{'errno':0,'errmsg':None,'unassigned':0,'total':0,'list':None}"

demjson

是什么：编码或解码JSON格式的库

作用：解决不正常的json格式字符串的转换

demjson两个常用的方法：

encode：将 Python 对象编码成 JSON 字符串
decode：将 JSON 字符串解码成python对象

eg：

import demjson



py_json="{x:1, y:2, z:3}"

py_json1 = "{'x':1, 'y':2, 'z':3}"

data = demjson.decode(py_json)

#  ------>   {'y': 2, 'x': 1, 'z': 3}

data1 demjson.decode(py_json1)

#  ------>   {'y': 2, 'x': 1, 'z': 3}



data2 = json.loads(py_json)

# ---->报错：json.decoder.JSONDecodeError: Expecting property name enclosed in double quotes

几个tips：

demjson 2.2.4 兼容python2和python3，Setuptools从版本58.0.0开始不再支持2to3的builds，所以会导致 demjson 2.2.4安装后不再可用，可降级setuptools版本：

pip install --upgrade setuptools==57.5.0

校验json schema

使用Free Online JSON to JSON Schema Converter将json字符串转换成json schema（注意开vpn）

from jsonschema import validators


schema = {
                          "$schema": "http://json-schema.org/draft-04/schema#",
                          "type": "object",
                          "properties": {
                            "data": {
                              "type": "object",
                              "properties": {
                                "eid": {
                                  "type": "integer"
                                },
                                "sid": {
                                  "type": ["string","null"]
                                }
                                  },
                                  "required": [
                                    "eid",
                                    "sid"
                                    
                                  ]
                                
                          },
                          "required": [
                            "data"
                           
                          ]
                        }




va = validators.Draft4Validator(schema)
va.validate(response)

断言

assert

assert xx ：判断 xx 为真
assert not xx ：判断 xx 不为真
assert a in b ：判断 b 包含 a
assert a == b ：判断 a 等于 b
assert a != b ：判断 a 不等于

eg：

断言某个字符串包含于某段字符串：assert (expectation['response']['message'] in response['message'])

常用tips

随机生成指定位数的字符串

import string

ran_str = ''.join(random.sample(string.ascii_letters + string.digits, 8))

截取指定位数的字符串

str[a:b]        #注意范围是前闭后开

判断一个字符串中包含多个字符串

p = "Tom is a boy,Lucy is a girl,they all like english!"
keywords= 'Tom,Lucy'
filters= ["boy","like"]
print all(f in p for f in filters)
>>>True
print all([w in p and w for w in keywords.split(',')])
>>>True

判断一个list包含另一个list

a = ['cc','ss','dd']
b = ['dd','aa','ss','cc']

                            
if set(a) < set(b):
    print("true")
else:
    print("false")




>> true

获取项目路径

对于一个独立的项目，所有的模块的追寻方式，最好从项目的根目录开始追溯，即相对的绝对路径。

获取当前程序所在位置的上级目录：

sys.path.append("..")

获取项目项目的路径：

dir = os.path.join(sys.path[1], '')

init.py

在 Python 2 规范中，用来表述包对外暴露的模块接口

在 Python 3 规范中，__init__.py 并不是必须的

if name == 'main'

作用：想把一个东西封装成模块，又想让它可以执行，就将要执行的代码放在 if __name__ == '__main__'下面。

原因：因为import 在导入文件的时候，会自动把所有暴露在外面的代码全都执行一遍，__name__ 就会被赋值为该模块的名字，不等于 __main__，所以import时不会执行if __name__ == '__main__'下面的代码。

eg：import该模块时不会打印“testing”，只有运行该模块时才会打印“testing”

def get_sum(a, b): 
    return a + b

if __name__ == '__main__': 
    print('testing')

统计list中各个元素出现的个数

三种方法：

1、利用dict字典

a = [1, 2, 3, 1, 1, 2]
dict = {}
for key in a:
    dict[key] = dict.get(key, 0) + 1
print dict



>>>{1: 3, 2: 2, 3: 1}

lists = [1, 2, 3, 4, 5, 6, 7, 5, 4, 3, 2, 12] 
dicts = {x: lists.count(x) for x in set(lists)}
print(dicts)





>>> {1: 1, 2: 2, 3: 2, 4: 2, 5: 2, 6: 1, 7: 1, 12: 1}

2、利用collection包下Counter的类

from collections import Counter
a = [1, 2, 3, 1, 1, 2]
result = Counter(a)
print result


>>>{1: 3, 2: 2, 3: 1}

3、利用pandas包下的value_counts方法

import pandas as pd
a = [1, 2, 3, 1, 1, 2]
result = pd.value_counts(a)
print result



>>>1    3
   2    2
   3    1

报错总结

报错信息：TypeError: sequence item 0: expected str instance, int found

eg：

list1=[1,'two','three',4]

print(','.join(list1))

报错：

Traceback (most recent call last):
File "", line 1, in
print(" ".join(list1))
TypeError: sequence item 0: expected str instance, int found

原因：list包含数字，不能直接转化成字符串。

解决：print(" ".join('%s' %id for id in list1))

报错信息：json.decoder.JSONDecodeError: Expecting property name enclosed in double quo

原因：str转换成json的时候，写了单引号

解决：把单引号改成双引号

报错信息：xlrd.biffh.XLRDError: Unsupported format, or corrupt file: Expected BOF record; found b'\xef\xbb\xbfaccou'

原因：csv文件直接修改后缀名，改成xls，导致读取excel文件失败

解决：重新保存csv文件，保存成xls格式即可

坑

python3.6之前，字典是无序的，所以用for循环时，输出的顺序！=写入的顺序，可以用：d1 = collections.OrderedDict()将字典变成有序的

参考文档：

Python中的*args和**kwargs（Python中的*args和**kwargs - 简书）

收录于

python

笔记

标签

#python

xlrd.biffh.XLRDError: Unsupported format, or corrupt file: Expected BOF record； found b‘\xb4\xfa\xc2 错误:xlrd.biffh.XLRDError: Unsupported format, or corrupt file: Expected BOF record; found b'\xb4\xfa\xc2\xeb\t\xc3\xfb\xb3' ecxcl 的表格不是问题与此页问题一致: 整个没有解决怎么解决windows平台下python 中xlrd模块对97-03 xls文件无法读取数据的问题 - OSCHINA - 中文开源技术交流社区1我用xlrd对excel文件进行数据读取，对0 阅读详情