Python1

缩进

Python 使用缩进来表示代码块。缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

基础数据类型

列表：[] ，元组（），字典｛｝

列表

# 增：向list列表中添加元素
names[0:0] = "小帅"  # 会将字符串分开添加
# 添加单个
names[0:0] = ["小帅"]
# 添加多个（起始位置和结束位置必须一致）
names[0:0] = ["小帅", "小鹿"]
names[0:2] = ["小帅", "小鹿"]  # 如果起始位置和结束位置不一致，则是修改

# 修改单个元素：
names[2] = "小王"
# 修改多个元素：
names[0:2] = ["小王", "小李"]
print(names)

查
获取list列表中的元素：
获取单个值：列表[下标]，下标可以为负数，负数是从倒数获取
获取多个值：列表[起始位置：结束位置：步长]，起始位置和结束位置可以省略不写；如果开始位置不写，则会从第一个元素开始获取；如果结束位置不写，则会获取到最后一个元素；如果都不写，则为列表的复制
获取单个：names[0],获取第一个元素
获取单个：names[-1],获取倒数第一个元素
获取多个：names[0:5]，获取下标0开始到下标5结束的元素；
names[:5]，从第一个元素获取到下标为5的元素
names[2:]，从下标为2的元素获取到最后一个元素

元组 tuple

元组Tuple是另一个数据类型，类似于 List（列表）。

元组用"()"标识。内部元素用逗号隔开。但是元素不能二次赋值，相当于只读列表。

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
 
print tuple # 输出完整元组
print tuple[0] # 输出元组的第一个元素
print tuple[1:3] # 输出第二个至第三个的元素 
print tuple[2:] # 输出从第三个开始至列表末尾的所有元素
print tinytuple * 2 # 输出元组两次
print tuple + tinytuple # 打印组合的元组

字典 DICT

字典
字典 (dictionary) 是除列表以外 Python 之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引 (key) 和它对应的值 value 组成。

Dictionary字典，就类似java中的Map集合，以“键值对”的形式存放数据，key不能重复

d = {key1 : value1, key2 : value2, key3 : value3 }

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
print dict['one'] # 输出键为'one' 的值
print dict[2] # 输出键为 2 的值
print tinydict # 输出完整的字典
print tinydict.keys() # 输出所有键
print tinydict.vaSlues() # 输出所有值
tinydict.getkey()

"""
Dictionary字典
d = {key1 : value1, key2 : value2, key3 : value3 }
"""
person = {"name": "张三", "age": 22, "sex": "女"}
# 获取值
print(person.get("age"))
print(person["name"])

# 修改
person["name"] = "小鹿"
print(person.get("name"))

del person["name"]
print(person)

# 遍历dict
for key in person.keys():
    print(f"{key}:{person.get(key)}")

for value in person.values():
    print(f"{value}")

for key, value in person.items():
    print(f"{key}:{value}")

SET 集合

set是一个无序且不重复的元素集合。

集合对象是一组无序排列的可哈希的值，集合成员可以做字典中的键。集合支持用in和not in操作符检查成员，由len()内建函数得到集合的基数(大小)， 用 for 循环迭代集合的成员。但是因为集合本身是无序的，不可以为集合创建索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值。

set和dict一样，只是没有value，相当于dict的key集合，由于dict的key是不重复的，且key是不可变对象因此set也有如下特性：

1. 不重复
2. 元素为不可变对象

a=set('boy')
b=set(['y', 'b', 'o','o'])
c=set({"k1":'v1','k2':'v2'})
d={'k1','k2','k2'}
e={('k1', 'k2','k2')}
print(a,type(a))
print(b,type(b))
print(c,type(c))
print(d,type(d))
print(e,type(e))

OUTPUT:
{'o', 'b', 'y'} <class 'set'>
{'o', 'b', 'y'} <class 'set'>
{'k1', 'k2'} <class 'set'>
{'k1', 'k2'} <class 'set'>
{('k1', 'k2', 'k2')} <class 'set'>

常见的函数：

比较不同：.difference()

删除：discard()、remove()、pop()

取交集：.intersection()

并集：union

判断：

se = {11, 22, 33}
be = {22}

print(se.isdisjoint(be))        #False，判断是否不存在交集（有交集False，无交集True）
print(se.issubset(be))          #False，判断se是否是be的子集合
print(se.issuperset(be))        #True，判断se是否是be的父集合

网址(https://www.cnblogs.com/whatisfantasy/p/5956775.html)

常见的遍历方式

使用for循环和enumerate()函数遍历列表

1. for index,变量元素 in enumerate(列表)
2.   输出index和变量元素

print("Python设计理念")
python = ["优雅","明确","简单"]
for index,linian in enumerate(python):
    print(index,linian)

使用for循环和range()函数遍历列表

定义，列表number 的列表，然后通过for循环和range()函数遍历该列表，并输出每条内容。代码如下：

number = [1122,2366,4400,5577,8888]
for i in range(len(number)):
    print(i,number[i])

用for循环和list()函数遍历列表

例如，定义python的设计理念，然后通过for循环和list()函数遍历该列表，并输出每条内容。代码如下

print("Python设计理念")
python = ["优雅","明确","简单"]
for linian in list(python):
    print(linian)

函数

局部函数

Python中的局部函数是在函数内部定义的函数，也被称为内部函数或嵌套函数。

局部函数的特点是：只能在定义它的函数内部调用，而不能在其他函数或全局作用域中调用。

可以减少全局命名空间的污染，提高代码可读性和可维护性。

# 全局函数 person()
def person():
    # 局部函数 men()
    def men():
        print('局部函数 men()')

    # 局部函数 women()
    def women():
        print('局部函数 women()')

    men()  # 在所在函数 person() 的作用域内调用局部函数 men()
    women()  # 在所在函数 person() 的作用域内调用局部函数 women()


person()  # 调用全局函数 person()
men()  # 局部函数默认只能在其所在函数的作用域内使用，否则会报错

扩大局部函数的使用范围

将局部函数作为所在函数的返回值，可以扩大局部函数的使用范围，既可以在所在函数内部使用，也可以在所在函数的作用域中使用。

举例如下所示：

# 全局函数 person()
def person():
    # 局部函数 men()
    def men():
        print('局部函数 men()')

    # 局部函数 women()
    def women():
        print('局部函数 women()')

    return men  # 将局部函数 men() 作为所在函数 person() 的返回值


new_men = person()  # 调用全局函数 person()
new_men()  # 调用局部函数 men()

运行结果：

局部函数 men()

遮蔽问题

局部函数和所在函数中有变量同名，就会发生“遮蔽”问题。

举例如下所示：

# 全局函数 person()
def person():
    name = '码农阿杰'
    # 局部函数 men()
    def men():
        print(name)  # 试图调用所在函数中的 name 变量，会发生“遮蔽”问题，报 UnboundLocalError 
        错误
        # 使用 nonlocal 关键字修饰，避免“遮蔽”
        name = '阿杰'

    men()


person()  # 调用全局函数 person()

函数名调用函数的几种方法

>>> def foo():
        print "foo"
 
>>> def bar():
        print "bar"
 
>>> func_list = ["foo","bar"]
>>> for func in func_list:
        func()
TypeError: 'str' object is not callable
我们希望遍历执行列表中的函数，但是从列表中获得的函数名是字符串，所以会提示类型错误，字符串对象是不可以调用的。如果我们想要字符串变成可调用的对象呢？

>>> for func in func_list:
        eval(func)()
foo
bar

eval() 通常用来执行一个字符串表达式，并返回表达式的值。在这里它将字符串转换成对应的函数。eval() 功能强大但是比较危险（eval is evil），不建议使用。

locals()和globals()

>>> for func in func_list:
        locals()[func]()
foo
bar
 
>>> for func in func_list:
        globals()[func]()
foo
bar

locals() 和 globals() 是python的两个内置函数，通过它们可以一字典的方式访问局部和全局变量。

getattr()

getattr() 是 python 的内建函数，getattr(object,name) 就相当于 object.name，但是这里 name 可以为变量。

>>> class Foo:
    def do_foo(self):
        ...
 
    def do_bar(self):
        ...
 
>>> f = getattr(foo_instance, 'do_' + opname)
>>> f()

借助列表调用

最简单的办法是通过一个将字符串映射到函数的字典，例如：

def func1():
    print("func1 was called.")

def func2():
    print("func2 was called.")

d = {'f1': func1, 'f2': func2} 

d['f1']()

func1 was called.

lambda 函数

1.lambda可以立即传递（无需变量），自行返回结果

2.lambda在内部只能包含一行代码

3.lambda是一个为编写简单函数而设计的，而def用来处理更大的任务

4.lambda可以定义一个匿名函数，而def定义的函数必须有一个名字

lambda函数的优势：

1.对于单行函数，使用lambda表达式可以省去定义函数的过程，让代码更加简洁

2.对于不需要多次复用的函数，用lambda表达式可以在用完后立即释放，提高程序执行的性能。

（1）简单用法

# 求两数之和
sum = lambda a, b: a + b
print(sum(1,2))

（2）将lambda作为函数返回

# 作为函数
def sum(a):
    return lambda b:a + b
a = sum(3)
print(a(4))

解释：这里定义了一个sum函数，返回了一个lambda表达式。其中lambda表达式获取到了上层def作用域的变量名a的值。x是sum函数的返回值，x(4)，即是调用了sum返回的lambda表达式

（3）在处理一个可迭代对象如列表，字典等时，可以用map(lambda, x) 代替 for…in…循环

# 将列表中的每个数翻倍
lis = [2,5,6]
print(list(map(lambda x:x*x, lis)))
输出：4 25 16

map() 会根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

map讲解：https://www.runoob.com/python/python-func-map.html

(4）filter过滤

lis = [2,5,6] ````x = filter(lambda x: x > 3, lst) print('大于3的数字有：', list(x))

(5) sorted排序

d = {'a': 25, 'c': 27, 'b': 20, 'd': 22}
b = sorted(d.items(), key=lambda x: x[1])
print(b)  

(6)lambda和if结合使用

funcb = lambda x:x+1 if x==1 else 0
funcb(1)
out:2
funcb(2)
out:0

with语法糖

对比

一般文件操作都会面临一个问题：由于读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用。所以，为了保证无论是否出错都能正确的关闭文件，我们先使用try… finally来实现

使用try … finally：使用这种方式，无论如何最后文件都会关闭，解决了上述问题，但是代码比较繁琐，我们思考有没有简单的方式

    # 1.以读的方式打开文件
    f = open('1.txt','r')
try:
	# 2.进行文件操作
	f.write('xxxxx') # 这一步会引发异常

except IOError as e:
	print("文件操作出错",e)

finally:
	f.close()

    # 1.以读的方式打开文件
	with open('1.txt','r') as f:
	# 2.进行文件操作
	f.write('xxxxx') # 这一步会引发异常,但是由于使用的with，文件会自动关闭，不会捕获异常
	使用 with 关键字系统会自动调用 f.close() 方法， with 的作用等效于 try/finally 语句是一样的。
    我们可以在执行 with 关键字后检验文件是否关闭：

使用 with 关键字：这种方式，当文件发生异常时，文件将自动关闭。将f贴给open的返回值，当离开with代码块时，系统可以自动调用f.close()方法，那么它的实现原理是什么值得研究？为了研究这种方式，先需要学习什么是上下文管理器

class Sample:
    def __enter__(self):
        print "in __enter__"
        return "Foo"
    def __exit__(self, exc_type, exc_val, exc_tb):
        print "in __exit__"
def get_sample():
    return Sample()
with get_sample() as sample:
    print "Sample: ", sample

（１）紧跟with后面的语句被求值后，返回对象的“–enter–()”方法被调用，这个方法的返回值将被赋值给as后面的变量；
（２）当with后面的代码块全部被执行完之后，将调用前面返回对象的“–exit–()”方法。

可以看到，整个运行过程如下：
（１）enter()方法被执行；
（２）enter()方法的返回值，在这个例子中是”Foo”，赋值给变量sample；
（３）执行代码块，打印sample变量的值为”Foo”；
（４）exit()方法被调用；

【注：】exit()方法中有３个参数， exc_type, exc_val, exc_tb，这些参数在异常处理中相当有用。
exc_type：　错误的类型
exc_val：　错误类型对应的值
exc_tb：　代码中错误发生的位置
示例代码：

class class Sample():
    def __enter__(self):
        print('in enter')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print "type: ", exc_type
        print "val: ", exc_val
        print "tb: ", exc_tb
    def do_something(self):
        bar = 1 / 0
        return bar + 10
with Sample() as sample:
    sample.do_something()

输出如下
in enter
Traceback (most recent call last):
type:  <type 'exceptions.ZeroDivisionError'>
val:  integer division or modulo by zero
  File "/home/user/cltdevelop/Code/TF_Practice_2017_06_06/with_test.py", line 36, in <module>
tb:  <traceback object at 0x7f9e13fc6050>
    sample.do_something()
  File "/home/user/cltdevelop/Code/TF_Practice_2017_06_06/with_test.py", line 32, in do_something
    bar = 1 / 0
ZeroDivisionError: integer division or modulo by zero

Process finished with exit code 1

实际上，在with后面的代码块抛出异常时，exit()方法被执行。开发库时，清理资源，关闭文件等操作，都可以放在exit()方法中。
总之，with-as表达式极大的简化了每次写finally的工作，这对代码的优雅性是有极大帮助的。
如果有多项，可以这样写： With open('1.txt') as f1, open('2.txt') as f2:

上下文管理器：上下文管理器本质就是能够支持with操作的类或对象。任何实现了__ enter __ ()和__ exit __()方法的类对象对可以称之为上下文管理器。上下文管理器对象可以使用with关键字对上下文管理，显然，文件(file对象)也实现了上下文管理协议(上面的两个方法)

ZIP和enumerate

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

以下是 enumerate() 方法的语法:

enumerate(sequence, [start=0])

• sequence -- 一个序列、迭代器或其他支持迭代对象。
• start -- 下标起始位置的值。

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

ZIP

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

zip 方法在 Python 2 和 Python 3 中的不同：在 Python 3.x 中为了减少内存，zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]