python入门

python指定字符编码（utf8）：

#！/usr/bin/env python

# _*_ coding:utf-8 _*_

# -*- coding:utf-8 -*-

# coding:utf-8

python基本数据类型

字符串：用单引号或者双引号包起来

数字

bool

流程控制

if - elif - else

while

while - else

break

continue

for

for - else

enumrate：遍历序列中的元素及他们的下标。

character=["a","b","c","d"]

for key, value in enumrate(character):

print(key, value)

range和xrange

range在Python2.7中，会把所有的序列都输出出来，没一个序列都在内存中占用一点空间

xrang不会一次性把序列全部都存放在内存中，而是用到for循环进行迭代的时候才会一个一个的存到内存中，相当于Python3.5中的range。

range在python3.5中就不会一次性的占用那么多空间，他会我需要用到这个序列的时候然后再内存中开辟一块空间给这个序列，不是一次性分完，相当于Python2.7.11中的xrange.

条件判断

if

if ... and  ... :

if ... or ... :

python基本的数据类型

数字、字符串、列表、字典、元组

所有的数据类型所具备的方法都存在相对应的类里面，当创建一个类型的对象时，该对象所具备的功能都保存在相应的类中。

对象是基于类的，也就是说如果我定义一个数据类型是字符串类型的，那么类型字符串就是类，二定义的变量就是对象，对象所拥有的功能都是从类里面去拿的。

可变类型与不可变类型

不可变类型(数字、字符串、元组、不可变集合)：不可变的类型是不支持修改原数据的，每次对不可变类型的数据进行修改时都是重新创建一个对象然后赋值给变量。

可变类型(列表、字典、可变集合)：可变类型是支持修改源数据，而不用重新创建新的对象

数字类型的长度限制：2.7中分int和long范围不一样，3.x中不区分可以保存任意数字。

数字类型的方法：

bit_length：该数字占用的最少位数

conjugate：该复数的共轭复数

imag：复数的虚数

整数比浮点数简单、浮点数比复数简单。

集合(set)

集合的元素是不允许重复、不可变且无序的集合

创建集合：s = set([11,22,33])   s = {11,22,33}

集合的方法：

add（添加）、clear（清除）、difference（set1中有，set2中没有的）、difference_update（set1中有，set2中没有的，并且赋值给set1）、

discard（移除指定元素，不存在不报错）、remove（移除指定元素，不存在报错）、

intersection（交集）、intersection_update、isdisjoint（是否有交集）、issubset、issuperset、

pop（移除一个元素，显示移除的元素）、symmetric_difference（对称交集，把两个都没有的元素存在一起）、symmetric_difference_update（对称交集，保存到set1中）、

union（并集，有重复的只存一个）、update（把set1中的元素update到set2中）

字符串：用单引号、双引号、三引号包起来的字符序列

字符方法：自行help

str类型和bytes：3.x中输出是一个字符，2.x输出是按照直接输出。

索引就是位置、转义符、字符串中的+、切片

切片操作：

列表

name_list=[‘python‘, ‘php‘, java‘]

name_list=([‘python‘,‘php‘,‘java‘])

列表方法：自行help

字典

dic = {"k1":"123","k2":"456"}

dic = dict({"k1":"123","k2":"456"})

字典方法：自行help

元组

元组(tuple)和列表的为唯一区别就是列表可以更改，元组不可以更改，其他功能与列表一样

ages=(11,22,33,44,55)

ages=tuple((11,22,33,44,55))

元组的元素本身是不可修改的，但是如果元组的元素是个列表或者字典那么就可以被修改

运算符

+、-、*、/、%、**、//（整除余，返回商的整数部分）

==、!=、<>、>、<、>=、>=

=、+=、-=、*=、/=、%=、**=、//=

and、or、not

in、not in

variable=value1 if condition else value2

字符集

2.x版本使用ascii字符集，3.x使用utf8字符集

深浅拷贝

数字和字符串对于深浅拷贝没有任何意义，他们的值永远指向同一内存地址。

字典、元祖、列表深浅拷贝时，内存地址的变化不同。

浅拷贝：在内存中只额外创建第一层数据。创建第一个变量和第二个变量，他们的内存地址不同，但是两个变量里面的值的内存地址相同。

深拷贝：在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化）。直接把第一个变量的内容直接拷贝给第二个变量，所以两个变量的内存地址不同，并且两个变量的值的内存地址也不同。

函数（function）

函数的写法、函数的返回值、函数的默认值、函数的动态参数、

动态参数可以接受用户输入的任何参数，包括字典、列表、元组等数据类型。

nonlocal：修改嵌套作用域中的变量，类似于golbal。只需要在嵌套函数中声明变量名即可，但是这个变量名是必须已经存在的否则就会报错，如果要修改的变量在作用域中查找不到，那么不会继续到全局或内置作用域中查找。

Lambda表达式

用lambda关键字创建的匿名函数，可以用于任何需要函数对象的地方，在语法上，被局限于只能有一个单独的表达式。

func=lambda x,y : x+y

func(1,2)

等效于下面函数

def func(x,y):

return x+y

python3内置函数

abs(x)

all(iterable)

any(iterable)

ascii(object)

bin(x)

bool([x])

callable(object)

chr(i)

classmethod(function)

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

complex([real[, imag]])delattr(object, name)

dict(**kwarg)

dir([object])

divmod(a, b)

enumerate(iterable, start=0)

eval(expression, globals=None, locals=None)

exec(object[, globals[, locals]])

filter(function, iterable)

float([x])

format(value[, format_spec])

frozenset([iterable])

getattr(object, name[, default])

globals()

hasattr(object, name)

hash(object)

help([object])

hex(x)

id(object)

input([prompt])

int(x, base=10)

isinstance(object, classinfo)

issubclass(class, classinfo)

iter(object[, sentinel])

len(s)

list([iterable])

locals()

map(function, iterable, …)

max(iterable, *[, key, default])

memoryview(obj)

min(iterable, *[, key, default])

next(iterator[, default])

oct(x)

open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

ord(c)

pow(x, y[, z])

property(fget=None, fset=None, fdel=None, doc=None)

range(start, stop[, step])

repr(object)

reversed(seq)

round(number[, ndigits])

set([iterable])

setattr(object, name, value)

slice(start, stop[, step])

sorted(iterable[, key][, reverse])

staticmethod(function)

str(object=b’’, encoding=’utf-8’, errors=’strict’)

sum(iterable[, start])

super([type[, object-or-type]])

tuple([iterable])

type(object)

vars([object])

zip(*iterables)

import(name, globals=None, locals=None, fromlist=(), level=0)