环境配置

默认搜索路径PYTHONPATH =/usr/local/lib/python/

以.py文件格式存储

执行.py文件

$ python test.py

检查python是否安装

$ python

安装python指令解析器，下载好源码包后进入目录执行下列指令

$ ./configure  --prefix=/usr/local
$ make && sudo make install

安装第三方库

pip是通用的python包管理工具，提供了对 python 包的查找、下载、安装、卸载、更新等功能。安装诸如pygame、pymysql、requests、django等python包时，都要用到pip。

常用pip命令

pip list #查看pip安装的模块名和版本						
pip -v #查看pip版本						
pip install 模块名 #安装模块
pip install 模块名==版本号	#安装指定版本                       
pip uninstall 模块名	#通过pip命令安装第三方库

通过pip指令安装库文件

sudo pip3 install numpy
sudo pip3 install pandas

模块（文件）

import os
os.getcwd() #模块内函数的使用

包（文件夹）

包其实就是文件夹，更确切的说，是一个包含__init__.py文件的文件夹。因此，如果我们想手动创建一个包，只需进行以下 2 步操作：

1. 新建一个文件夹，文件夹的名称就是新建包的包名；
2. 在该文件夹中，创建一个 __init__.py 文件（前后各有 2 个下划线‘_’），该文件中可以不编写任何代码。

注释

# 这是单行注释

'''
这是使用三个单引号的多行注释
'''

"""
这是使用三个双引号的多行注释
"""

变量

所有类型都是对象，都继承自同一个基类。声明一个对象本质是声明一个指向这个基类对象的智能指针。

python中的变量类型	c++中的对应类型
32位整数类型	int
long（python 3淘汰）	long
	float
complex	complex
string	string	''
byte	byte	b''
list	list	[]
tuple（元组）		()
dictionary（字典）
函数变量		f()

val = 'Hello World!'																#string
val = b'Hello World!'																#byte
val = ['Michael', 'Bob', 'Tracy']  												 	#list
val = ( 'runoob', 786 , 2.23, 'john', 70.2 )						 #tuple
val['one'] = "This is one"															#dictionary
val[2] = "This is two"																#dictionary
val = {'name': 'runoob','code':6734, 'dept': 'sales'} #dictionary
val = 123
val = 51924361L
val = 0.0
val = 3.14j

val = ''		#字符串
val = []		#
val = ()

作用域

用:表明作用域

#while示例
count = 0
while (count < 9):
   print 'The count is:', count
   count = count + 1

#for示例
for letter in 'Python': 
   print '当前字母 :', letter

#if示例
if name == 'python':         
    print 'welcome boss' 
else:
    print 'hello'  

age = 3
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')

变量的作用域

g_b = 3
def t1():
    global g_b
    g_b = 2
t1() #g_b值为2

g_b = 3
def t1():
    g_b = 2
t1() #g_b值为3

函数

用def定义函数

由于python中无需指明变量类型，所有变量可以相互转化。所以函数不需要指出返回类型，函数参数也不需要指出变量类型。

def printinfo( name, age ):
   "打印任何传入的字符串"
   print "Name: ", name
   print "Age ", age
   return

#调用printinfo函数
printinfo( age=50, name="miki" )

函数可以有多个返回值

可变参数函数

def calc(*numbers):

返回函数

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

lambda函数

# 定义函数
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )

for循环

range()

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

in

break continue pass

# 输出 Python 的每个字母
for letter in 'Python':
   if letter == 'h':
      pass
      print '这是 pass 块'
   print '当前字母 :', letter
 
print "Good bye!"

类

class Student(object):		#继承自object类
   #静态变量直接在类中声明
   __secretCount = 0  # 私有静态变量
   publicCount = 0    # 公有静态变量
   #构造函数
   def __init__(self, name, score):
       #普通成员变量在构造函数中声明
       self.name = name 		#普通公有成员变量
       self.__score = score      #普通私有成员变量
   #析构函数
   def __del__(self): 
       pass
   
   #公有成员函数，参数为self
   def print_score(self):		 
       print('%s: %s' % (self.name, self.score)
   #静态成员函数，参数为空
   @staticmethod
   def print_static(): 
       pass
   #类成员函数，参数为cls      
   @classmethod
   def print_class(cls): 
       pass
            
   #普通私有成员函数，以"__"为前缀
   def __print_private(self):  
       pass

private/protected/public成员
__function__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__()之类的。也可以是特殊变量，是可以直接访问的，不是private变量，所以，不能用__name__、__score__这样的变量名。
_function: 以单下划线开头的表示的是 protected 类型的变量和方法，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
__function: 双下划线的表示的是**私有类型(private)**的变量, 只能是允许这个类本身进行访问了。私有方法：以 __两个下划线开头，声明该方法为私有方法，只能在类的内部调用 （类内部别的方法可以调用他），不能在类地外部调用。

继承

只有公有继承

class A:        # 定义类 A
.....
class B:         # 定义类 B
.....
class C(A, B):   # 继承类 A 和 B

可动态添加和删除成员变量

class people:
    pass
p=people()
#动态添加属性
p.sex = "nan" #若有sex公有成员，则修改sex为'nan'，若无成员sex，则添加成员sex
#动态删除属性
del p.sex
##同上，获取一个属性
getattr(p,"age",0)
##动态添加一个属性
setattr(p,"sex","nv")
##动态删除一个属性
delattr(p,"sex")
##是否拥有该属性
hasattr(p,"age")

静态成员和非静态成员

静态方法没有类似 self、cls 这样的特殊参数；类方法最少也要包含一个参数self或者cls

class Foo(object):
    count = 0

f1 = Foo()
f2 = Foo()
f1.count = 1  #通过对象名访问非静态成员
print(f1.count, f2.count)
# 结果:
1 0
Foo.count = 1 #通过类名访问静态成员
print(f1.count, f2.count)
# 结果:
1 1
'''
结果不同的原因：f1.count访问的是非静态成员count，但类内无非静态成员count，故添加count成员变量，但此时静态成员变量count并没有改变；Foo.count访问的是静态成员count
‘‘‘

特殊成员方法	功能
__init__()	构造函数
__del__()	析构函数
__doc__()	打印类的描述信息
__module__()	表示当前操作的对象在那个模块
__class__()	表示当前操作的对象的类是什么
__dict__()	查看类或对象中的所有成员
__new__()

supper getter setter property __slots__ type

子类调用父类的方法

class Car:
    def __init__(self,name):
        self.name = name
        print('父类的构造方法被调用。。。')
 
class AutoCar(Car):
    def __init__(self,name,age):
        #Car.__init__(self,name)              #方式一
        super(AutoCar,self).__init__(name)    #方式二
        self.age = age
        print('子类的构造方法被调用。。。')

不变类型和可变类型

参数传递中的概念，可变类型相当于c++中的引用传递；不可变类型相当于值传递。

不可变类型：类似 c++ 的值传递，传递的只是a的值，没有影响a对象本身。比如在 fun(a)内部修改 a的值，只是修改另一个复制的对象，不会影响 a 本身。

可变类型：类似 c++ 的引用传递，fun(a)则是将 a 真正的传过去，修改后fun外部的a也会受影响

数据类型	可变/不可变
整数/浮点数	不可
字符串	不可
tuple	不可
list	可
set	可
dictionary	可

字符编码

ASCII

utf-8—英文字母被编码成1个字节，汉字通常是3个字节—

unicode——英文字母2字节，汉字通常2字节（如果要用到非常偏僻的字符，就需要4个字节）

Python提供了ord()函数获取字符的整数表示，chr()函数把十进制转换为对应的字符

Python的字符串类型是string，在内存中以unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把string变为以字节为单位的bytes

byte类型和string类型都是对象，但byte内以字节方式存储数据，string内以unicode方式存储数据

STL

查找

插入

删除