基础数据类型

list

  1. 创建
list1 = ['str', 'str2', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];

  1. 访问数据
list[0];
list[1:5] #返回下标1，5之间的数据
list[-3]
list[-3:] #返回倒数第三个数据以及之后的数据

3.修改数据


listz+['sd',12,23] # 拼接list
list.append(232);
list[2:5] = ['C', 'D', 'E'] #修改下标2,5之间的数据
list[2:5] =[] #
list[:] =[] # 移除数据

a = [1,23]
b=['23',32]
c=[a,b] # 内嵌list
len(a) # 内置函数



4.内置函数

方法 描述
list.append(x) 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L) 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x) 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
\list.remove(x) 删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i]) 从列表的指定位置删除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被删除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear() 移除列表中的所有项，等于del a[:]。
list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x) 返回 x 在列表中出现的次数。
list.sort() 对列表中的元素进行排序。
list.reverse() 倒排列表中的元素。
list.copy() 返回列表的浅复制，等于a[:]。
for i, v in enumerate([‘tic’, ‘tac’, ‘toe’]): 遍历list 索引，值

list–> deque

列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

列表映射

>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]
现在我们玩一点小花样：

>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
这里我们对序列里每一个元素逐个调用某方法：

>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']


  • 同时遍历多个序列
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

元组

  1. 创建同list

  2. 元组不予许修改（但是del可以删除整个元组）

  3. 内置函数

Python 表达式 描述
len((1, 2, 3)) 计算元素个数
(1, 2, 3) + (4, 5, 6) 连接
(‘Hi!’) * 4（结果 (‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)） 复制
3 in (1, 2, 3)（返回bool） 元素是否存在
for x in (1, 2, 3) 迭代
max(1,2) 返回最大值
tuple(list) list转元组

dict

dict 字典{‘key’:value}其中key可以是任意不可变类型且必须唯一，value则是任何数据类型都可。类似于hashmap

  1. 删除元素
del dict['name']
del dict
dict.clear()

2.映射

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
序号 函数及描述
len(dict) 计算字典元素个数，即键的总数。
str(dict) 输出字典以可打印的字符串表示。
type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
for k, v in knights.items() 遍历键值对

radiansdict.copy() 返回一个字典的浅复制

radiansdict.fromkeys(seq[,val]) 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

radiansdict.get(key, default=None)
返回指定键的值，如果值不在字典中返回default值

key in dict
如果键在字典dict里返回true，否则返回false

radiansdict.items()
以列表返回可遍历的(键, 值) 元组数组

radiansdict.keys()
以列表返回一个字典所有的键

radiansdict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

radiansdict.update(dict2)
把字典dict2的键/值对更新到dict里
radiansdict.values()
以列表返回字典中的所有值

集合

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素（常见的集合操作 交并差）。

可以用大括号 ({}) 创建集合。注意：如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典，下一节我们会介绍这个数据结构。

b=set(list)
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # fast membership testing
True
>>> 'crabgrass' in basket
False

>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b                              # letters in either a or b
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # letters in both a and b
{'a', 'c'}
>>> a ^ b                              # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}

函数

可变参数列表

可变参数列表，参数被包装进一个元组(查看元组和序列)。
在这些可变个数的参数之前，可以有零到多个普通的参数:

def arithmetic_mean(*args):
   for i in args:
      print i


模块

模块类似于代码的文件性封装，在文件内自成一个变量的作用域，不影响外部文件的变量。

__name__属性

  1. 每个模块都有一个 name 属性

  2. 一个模块被另一个程序第一次引入时，其主程序将运行。
    如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用 name 属性来使该程序块仅在该模块自身运行时执行。
    (作用之一，是在开发完一个模块时，在该模块中测试，单独写一个块测试方法，完了要被引入的时候不执行该块)


#!/usr/bin/python3
# Filename: using_name.py

if __name__ == '__main__':
 print('程序自身在运行')
else:
 print('我来自另一模块')
运行输出如下：

$ python using_name.py
程序自身在运行
$ python
>>> import using_name
我来自另一模块
>>>

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:

包

如果说模块是代码，多个方法的封装，那么包就是模块的封装

init.py

  1. 每个包都有一个__init__.py 文件

  2. 目录只有包含一个叫做 init.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。

  3. 最简单的情况，放一个空的 :file:init.py 就可以了。当然这个文件中也可以包含一些初始化代码或者为（将在后面介绍的） __all__变量赋值。

all

如果包定义文件 init.py 存在一个叫做 all 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入

__all__ = ["echo", "surround", "reverse"]

path

包位于操作系统的物理存储路径

输入输出

str.format()

print('hello {}orld{}'.format('w','!'))

%

% 操作符也可以实现字符串格式化。 它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串. 例如:

>>> import math
>>> print('The value of PI is approximately %5.3f.' % math.pi)
The value of PI is approximately 3.142.

因为 str.format() 比较新的函数， 大多数的 Python 代码仍然使用 % 操作符。但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format().

面向对象

class A:
   #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
   # 构造方法
   def __init__(self):
       self.data = []


class B(A):
   ...

# 需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，
# Python 从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。
class C(B,D,E):
   ...




类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法

在类地内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 slef.__private_methods。

类中内置函数

init : 构造函数，在生成对象时调用
del : 析构函数，释放对象时使用
repr : 打印，转换
setitem : 按照索引赋值
getitem: 按照索引获取值
len: 获得长度
cmp: 比较运算
call: 函数调用
add: 加运算 对象+
sub: 减运算 对象-
mul: 乘运算
div: 除运算
mod: 求余运算
pow: 乘方

运算符重载

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

类中property属性

property对象值写法

对属性的get set del doc说明包装
如果 c 是 C 的实例化, c.x 将触发 getter,c.x = value 将触发 setter ， del c.x 触发 deleter。
如果给定 doc 参数，其将成为这个属性值的 docstring，否则 property 函数就会复制 fget 函数的 docstring（如果有的话）。

class C(object):
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")


#
# fget -- 获取属性值的函数
# fset -- 设置属性值的函数
# fdel -- 删除属性值函数
# doc -- 属性描述信息
c = C()
c.x = "你好吗"
print(" {} {} ".format(c.x,c.__doc__))

装饰器写法

以上写法类似于

# 只有python3的类中继承object才有 下面的写法 python3中默认类继承object
class D:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x


d = D()
d.x = 123
print("{}".format(d.x))

with的自动关闭资源

  1. 任何实现了__enter__ __exit__方法的对象都可以称为上下文管理器，上下文管理器对象都可以使用with关键字。file就实现了。
  2. 上下文：我们知道不同的语句在不同的场景中说出中其寓意大不形同，而上下文管理器就是这样一个管理代码运行的上下文环境的东东，
    在__enter__式记录该下文所需要的资源对象，在下文中使用完资源退出__exit__自动将资源关闭，以减少code量。

class  File():
   def __enter__(self):
      self.f = open(self.filename,self.mode)
      return self.f
   
   def __exit__(self):
      self.f.close()


###


with open ("input.txt","r") as f:
   f.write("hello world!!!")

装饰器写法

from contextlib import contextmanager

@contextmanager
def my_open(path,mode):
   f= open(path,mode)
   yield f
   f.close()