语言简介：

  • python是一种编程语言，同C、java语言类似。C语言是可以用来编写操作系统的贴近硬件的语言，适合开发那些追求运行速度、充分发挥硬件性能的程序。而python是一种高级编程语言，适合用来编写应用程序。python语言的定位是“优雅”“明确”“简单”，所以python程序看上去简单易懂，不但初学者入门容易，而且将来深入下去还可以编写那些非常非常复杂的程序。

  • python一个缺点是运行速度慢，和C语言相比非常慢，因为Python是解释型语言，在代码执行时会一行一行的翻译成CPU能理解的机器码，这个过程非常耗时，所以很慢。但是我们不用担心，因为大量的应用不需要这么快的速度，而且用户根本感觉不出来。如果真的有特别需要效率的地方可以用其他语言重新以提升效率。

特点：

  • python是高级编程语言，实现同样的功能相比其他语言如java只需要更少的代码。

  • python提供了完善的基（内置库）础代码库，包括网络、文件、GUI、数据库、文档等大量内容，用python开发，许多功能不必从零编写，可以直接使用现成的即可。同时python还有大量的第三方库（如django），也就是别人开发的可以拿来直接使用的东西。如果自己开发的代码通过很好的封装，也可以作为第三方库给别人使用。

用途：

  • 网络应用，如网站、后台服务等。很多著名的网站如YouTube、Instagram、豆瓣就是python写的；

  • 编写日常小工具，如脚本任务、自动备份、下载任务等。

  • 把其他语言开发的程序再包装起来，方便使用。

  • 爬虫、数据分析等

4 基本数据类型

4.2 组

组分为序列和集合，列表、元组、字符串可视为序列，dict和set是集合，两者的区别是序列是有序的，集合是无序的。

4.2.1 字符串(str)

用单引号、双引号包含起来的字符为字符串。 注意：引号均为英文状态下输入，用于表示字符串时需要成对出现。

  1.   >>>'hello,reedo'  # 字符串可以用单引号也可以用双引号，同"hello,reedo"
  2.   'hello,reedo'
  3.   >>>'1'   #此时表示字符串，而部署数字， 可用type('1') 查看
  4.   '1'
  5.   >>>"let's go"   # 双引号成对表示字符串，其中单引号为字符串内容
  6.   "let's go"

多行字符：

  1. 多行输入字符串使用三引号

    1. >>> """hello
    2. world
    3. """
    4. 'hello \n word'

  2. 换行前输入\也可实现换行输入

    1. >>>'hello\
    2. word'
    3. 'hello word'

转译字符： 用于表示无法看见的或语法冲突的字符

  • \n 换行

  • \r回车

  • \'单引号

  • \\ 反斜杠\

原始字符串：字符串不转译，直接输出： 使用r''

  1.   >>>print(r'c:/nobody/now')
  2.   'c:/nobody/now'

字符串操作：

  1.   >>>'hello' + 'world'  #字符串拼接
  2.   'helloworld'
  3.   >>>'hello'*3   #字符串复制
  4.   'hellohellohello'
  5.   >>>'hello'[0] #字符串截取,根据字符串下标，第一个字符下标为0，截取为区间时左闭右开
  6.   'h'
  7.   >>>'hello'[0:3]
  8.   'hel'

空值：None 注意：None不等同于0、False等。

4.2.2 列表(List)

List是Python内置的一种有序的、可变的复合数据类型，用于将其他值组合在一起。用方括号包含，不同值之间用逗号分隔开，列表的值可为不同类型。

  1.   >>> MyList = [11, 'aa', True]   #定义一个列表，可包含不同数据类型
  2.   >>> MyList
  3.   [11, 'aa', True]

像字符串（以及所有其他内置的序列类型），列表可以被索引和切片

  1.   >>>MyList[0]  # 索引，访问MyList索引为0的值，列表中第一个值的索引为0，后面的值依次为1，2，3...
  2.   11
  3.   >>> MyList[-1]  # 索引，访问MyList索引为-1的值，列表中倒数第一个索引为-1，右到左依次为-1,-2，...
  4.   True
  5.   >>>MyList[-2:]  #切片，会返回一个包含请求元素的新的列表
  6.   ['aa', True]
  7.   >>>MyList[:] # 返回一个列表的新副本
  8.   [11, 'aa', True]

列表连接：和其他列表连接(返回新的列表，不改变之前的列表数据)，如下操作：

  1.   >>>MyList+[11,22,33]
  2.   [11, 'aa', True, 11, 22, 33]

与不可变字符串不同，列表是一个可变的类型(改变现有列表内容)，也就是说可以改变他们的内容：

  1.   >>>cubes = [1,8,27,65,125]  # 定义一个列表
  2.   >>>cubes[3] = 64  # 更改列表索引为3（即第四个值65）的值为65
  3.   >>>cubes
  4.   [1,8,27,64,125]
  5.   >>>cubes[2:4]=['a', 'b']   # 替换某些值
  6.   >>>cubes
  7.   [1,8,'a','b',125]
  8.   >>>cubes[-2:]=[]  #删除某些值
  9.   [1,8,'a']
  10.   >>>cubes[:] = [] #通过用空列表替换所有元素来清除列表
  11.   []

也可以使用append()方法在列表末尾添加新的值（改变现有列表内容）

  1.   >>>cubes.append(216)
  2.   >>>cubes.append(7**3)
  3.   >>>cubes
  4.   [1,8,27,64,125,343]

内置函数len()可以用于获取列表长度

  1.   >>> letters = ['a', 'b', 'c', 'd']
  2.   >>> len(letters)
  3.   4

4.2.3元组(tuple)

元组（Tuble）和列表非常类似，只是元组一旦初始化就不能修改，用()表示，如：

  1.   Tuble = ('11', 1, 'aa')

总结：

  • str、list、tuple都时序列，都可通过角标、切片等访问、+、*、

  • in判断 、len()方法、max()\min(),

    1. >>> 2 in [1,2,3]   #in判断是否在序列中，返回True或False
    2. True
    3. >>> len('reedo')
    4. 5
    5. >>>max('abcdef') #是字符串是按照assic码返回，可用方法ord()查看对于的assic码
    6. f

4.2.4 集合（set）

集合是无序的，不可重复的

集合（set）同字典类似，是一组key的集合，但不存储value，用{}表示，如：

  1.   set = {'1', 1, 'aa'}

集合的常见操作：差积、并集、交集

  1.   >>>{1,2,3,4} - {3,4}  #排除第一个集合中的第二个集合中的元素
  2.   {1,2,}
  3.   >>>{1,2,3} | {3,4,5} #求两个集合的并集
  4.   {1,2,3,4,5}
  5.   >>>{1,2,3} & {3,4,5}  #求两个集合的交集
  6.   {3}

定义空的集合set()。 

  1.   >>>set()
  2.   set()
  3.   >>>type({})     #{}表示空的字典，而不是空的集合。
  4.   <class 'dict'>

4.2.5 字典(dict)

Python内置了字典，用{}表示，使用“key：value”存储,如{key1:value, key2:value2...}也属于集合类型，如：

  1.   >>> dict = {'name':'mike', 'age':21, 'position':'pm'}  #定义一个dict
  2.   >>>ditc['name'] #通过key访问value
  3.   mike

字典中value可以是任意类型如int、str、dict等，但key必须是不可变类型，如key不可以是列表（列表是可以变的）

5 变量与运算符

5.1 变量

5.1.1 什么时变量

变量：名字，可以将值赋值给变量，使用=赋值，如

  1.   >>>a = 1   #将数值1赋值给变量a
  2.   >>>name = 'mike'
  3.   >>> degree = ['优'， '良'， '中', '差']

注意：Python中变量是没有类型区别的（因为python是动态语言，不用先定义变量类型）

5.1.2 变量命名规范：

  • 变量一般可由数字、字母、下划线组成，不可纯数字，不可数字开头，区分大小写

  • 系统中保留关键字不可用在变量命名中

  • 编程中一般变量名取得要有意义，命名可读性强，一般使用英文名称，驼峰命名等。

  • 产量：不能变的变量，Python中一般全部用大写表示，如PI=3.14 但是PI还是变量，Python并没有任何限制保证常量不被改变。

5.1.3 值类型与引用类型变量区分：

  • int是值类型、list是引用类型，

  • 值类型不可改变，赋值给变量后变量不随值的改变而改变；引用类型是可变的，赋值给变量后变量随着数值的改变而改变

  • 值类型(不可变)包括：int、str、tuple； 引用类型(可变)包括：list、set、dict。

  1.   >>>a=1
  2.   >>>b=a
  3.   >>>a=2  #a重新指向一个新的值2
  4.   >>>b 
  5.   1
  7.   >>>c = [1,2,3]
  8.   >>>d = c
  9.   >>>c[0] = 4  #改变原来的[1,2,3]内容为[4,2,3],并没有重新赋新值，因此赋给d的值的内容也被改变
  10.   >>>d
  11.   [4,2,3]

5.2 运算符

5.2.1 算数运算符:

  • 加：+

  • 减：-

  • 乘：; 高阶乘：*

  • 除。 /：除、返回float； //：整除，返回int，不保留小数部分； %: 除取余

5.2.2 赋值运算符:

  • =

  • +=： 加计算后赋值：

    1. >>>a=1
    2. >>>a+=2  #等等于a=a+1,其他同理
    3. 3

  • -=

  • =、*=

  • /=、//=、%=
    注意：算数运算和赋值运算都可能含有运算逻辑，区别在于赋值运算运算后会重新赋值，改变原来变量赋值，而算数运算不会进行赋值，不会改变原来变量的值。

5.2.3 比较(关系)运算符:

值进行比较，返回True或False

  • == ： 比较值是否相等

    1. >>>1==1
    2. True
    3. >>>1 == 1.0  #虽然是不同类型，但是在数学是值相同
    4. True
    5. >>>[1,2,3] == [2,1,3] #list是无序的，值相同即返回True
    6. True
    7. >>>(1,2,3) ==(2,1,3) #tuple是有序的，按照位置比较，不相同
    8. False
    9. >>>1 == '1' 不同类型（数字、字符串）不同
    10. False

  • ！=

  • 、 = 、 、=
    注意：

    • 比较运算除了比较数值外还会比较类型，返回bool值True或False

    • 字符也可以进行比较，单个字符会按照对于的ascii码进行比较，多个字符时会依次对字符进行比较大小；元组列表会对其中的元素依次进行比较

5.2.4 逻辑运算符:

逻辑运算操作类型及返回类型都是布尔类型

  • and 、 or 、 not

注意：

  • int、float中0被认为是False，其他被认为是True，str、list、set、dict等中空被认为是False，其他被认为是True

  • and or 操作非布尔类型的值时会将运算值对应到True、False并按照运算逻辑返回最先能判断结果的对应的值。

    1. >>>1 and 2  #只有运算到2时才能判断返回结果为True，最快返回2
    2. 2
    3. >>> 1 or 2  #运算到1 or时就可以判断返回结果为True，最快返回代表True的1
    4. 1

5.2.5 成员运算符：

判断一个元素是否在一组元素中，返回True或False

  • in 、not in

注意：str、list、tuple判断元素中的值，dict判断元素中的key

5.2.6 身份运算符：

针对对象进行判断，比较两个变量身份是否相等（内存id是否相同），返回True或False 。相同对象（内存id相同）拥有相同值（==判断）、类型（isinstancepan判断）、id。

  • is 、 is not

5.2.7 位运算符(了解)：

针对int数字，把数字当作二进制进行运算，返回运算后10进制的值

  • & ：按位与 ： 二进制中对应位全部为1时取1，否则取0

  • | ：按位或： 二进制中对应位只要有1时取1，全部为0时取0

  • ^ ： 按位异或：

  • ~ ： 按位取反

  • << ： 左移动

  • ： 右移动

其补充知识点：

  • 判断类型是否相同用type或isinatance()方法
    1. >>>a = 'reedo'
    2. >>>type(a) =str
    3. True
    4. >>>isinstance(a, str)   #推荐
    5. True
    6. >>>isinstance(a, int)
    7. False
    8. >>>isinstance(a,(str, int)) #扩展知识， instance函数判断类型可以是元组。
    9. True

5.2.8 各运算关系：

表达式(Expression)是运算符(operator)和操作数(operand)所构成的序列

表达式优先级：

  • 算数运算符>比较运算符>身份运算符>逻辑运算符>赋值运算符

  • 算数运算符中：指数>乘除>加减

  • 逻辑运算符中：not > and >or

编号 运算符 描述
1 ** 算数运算符(指数)
2 * / % // 算数运算符（乘除）
3 + - 算数运算符（加减）
4 <= < > >= 比较运算符
5 <> == ！= 比较运算符
6 is is not 身份运算符
7 in not in 成员运算符
8 not 逻辑运算符（非）
9 and 逻辑运算符（且）
10 or 逻辑运算符（或）
11 = %= /= //= -= += = *= 赋值运算符

6 流程控制

6.1 条件判断

计算机之所以能做很多自动化的任务，是因为他可以自己做条件判断，在Python中可以用if实现这样的判断,语法如下：

  1.   if <条件判断1>:
  2.       <执行1>

eg：用户输入年龄，根据年龄打印除不同的内容

  1.   age = int(input('请输入年龄'))
  2.   if age >= 18:
  3.       print('成年人')

根据Python的缩进规则，如果if语句判断是True，就把缩进的两行print语句执行了，否则，什么也不做。

也可以给if添加一个else语句，意思是，如果if判断是False，不要执行if的内容，去把else执行了:

  1.   age = int(input('请输入年龄'))
  2.   if age >= 18:
  3.       print('成年人')
  4.   else:
  5.       print('未成年人')

还可以用elif做更细致的判断，语法如下：

  1.   if <条件判断1>:
  2.       <执行1>
  3.   elif <条件判断2>:
  4.       <执行2>
  5.   elif <条件判断3>:
  6.       <执行3>
  7.   else:
  8.       <执行4>

例如：

  1.   age = int(input('请输入年龄'))    #input返回的数据内容是str，如果要和数字比较需要转换为数字类型
  2.   if age >= 18:
  3.       print('成年人')
  4.   elif age >= 6:
  5.       print('青少年')
  6.   else:
  7.       print('还是个孩子')

说明：

  • if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else。

  • 判断条件中非零数值、非空字符串、非空list等，就判断为True，否则为False。

input()补充知识：

  • input可以获取用户的输入，并将输入内容赋值给变量

    1. a = input() #执行这句话时用户可以输入，并将输入的内容赋值给变量a。

  • input()内可以包含字符，在输入内容前进行提示：

    1. >>>input('输入姓名：')
    2. 输入姓名：|

6.2 循环

为了让计算机完成重复运算，就需要循环。Python中有for和while两种循环

6.2.1 for

for .. in循环，依次把list或tuple中元素迭代出来

  1.   names = ['Michael', 'Bob', 'Tracy']
  2.   for name in names:
  3.       print(name)

所以for x in ...循环就是把每个元素代入变量x，然后执行缩进块的语句。

  1.   sum = 0
  2.   for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
  3.       sum = sum + x
  4.   print(sum)
  5.   for y in range(1,10):
  6.       print(y)

补充知识：

  • 如果要计算1-100的整数之和，从1写到100有点困难，幸好Python提供一个range()函数，可以生成一个整数序列，再通过list()函数可以转换为list。比如range(5)生成的序列是从0开始小于5的整数：

  • range可以加入第三个参数表示步长

  1.   >>> list(range(5))
  2.   [0, 1, 2, 3, 4]
  3.   >>> list(range(1,10,2))
  4.   [1,3,5,7,9]
  5.   >>>list(range(5,0,-1))
  6.   [5,4,3,2,1]
  • print()默认是打印一次自动换行，可以加入第二个参数end=改变打印显示在一行

6.2.2 while

while循环，只要条件满足，就不断循环，条件不满足时退出循环。比如我们要计算100以内所有奇数之和，可以用while循环实现：

  1.   sum = 0
  2.   n = 99
  3.   while n > 0:
  4.       sum = sum + n
  5.       n = n - 2
  6.   print(sum)

break:在循环中，break语句可以提前退出循环。

  1.   n = 1
  2.   while n <= 100:
  3.       if n > 10: # 当n = 11时，条件满足，执行break语句
  4.           break # break语句会结束当前循环
  5.       print(n)
  6.       n = n + 1
  7.   print('END')

continue:在循环过程中，也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环。

  1.   n = 0
  2.   while n < 10:
  3.       n = n + 1
  4.       if n % 2 == 0: # 如果n是偶数，执行continue语句
  5.           continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
  6.       print(n)

注意:

  • 不要滥用break和continue语句。break和continue会造成代码执行逻辑分叉过多，容易出错。大多数循环并不需要用到break和continue语句，上面的两个例子，都可以通过改写循环条件或者修改循环逻辑，去掉break和continue语句。

  • 有些时候，如果代码写得有问题，会让程序陷入“死循环”，也就是永远循环下去。这时可以用Ctrl+C退出程序，或者强制结束Python进程。

包、模块、类、函数/变量介绍

7 函数

函数是具体计算的抽象

Python内置了很多有用的函数，我们可以直接调用，官网网站

7.1 定义函数

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

  1.   def myfunc(x):
  2.       return '你输入的是：'+x

使用pass可以定义一个空函数，空函数什么都不做，作为一个占位符，能让代码先运行起来

  1.   def nofunc():
  2.       pass

返回多个值：

使用return可以返回多个值（其实是一个tuple）。 在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值。 这种方式又称序列解包

  1.   import math
  2.   def move(x, y, step, angle=0):
  3.       nx = x + step * math.cos(angle)
  4.       ny = y - step * math.sin(angle)
  5.       return nx, ny
  6.   x, y = move(100, 100, 60, math.pi / 6)
  7.   print(x, y)  # 打印结果：151.96152422706632 70.0

补充知识：序列解包、链式赋值

  • 序列解包：将一个tuple分别赋值给参数：a,b,c = (1,2,3), 解包时接受的参数数需要与列表值相等。

    1. >>>a = 1,2,3 
    2. >>>a
    3. (1,2,4)

  • 链式赋值：a=b=c=1

总结：

  • 定义函数时，需要确定函数名和参数个数；

  • 如果有必要，可以先对参数的数据类型做检查；

  • 函数体内部可以用return随时返回函数结果；

  • 函数执行完毕也没有return语句时，自动return None。

  • 函数可以同时返回多个值，但其实就是一个tuple。

注意:

  • 函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。

  • 如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return。

7.2 函数的参数

定义函数的时候，我们把参数的名字和位置确定下来，函数的接口定义就完成了。对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样的值就够了，函数内部的复杂逻辑被封装起来，调用者无需了解。

Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。

在定义函数时编写的参数成为形式参数（形参）、在调用函数的是否填写的参数/参数值称为实际参数（实参）。

位置参数

必须参数

必须参数和关键字参数的区别在于函数的调用上而不在于函数的定义

默认参数：在定义函数的时候给形参赋予默认值，在调用的是否默认参数可以不传值

注意：

  • 必须参数需要在默认参数之前

  • 调用函数时必须参数必填，可不填，也可按顺序全部填写，如果默认参数不安顺序填写时需指定关键字参数

可变参数：

  1.   def funcname(*param):
  2.       return param

函数会自动把变化的参数组装乘tuple

注意：

  • 调用可变参数的函数时，如果传入的参数本身就是元组，则可以通过*+元素的方式传入。

关键字可变参数：可以支持任意个数的关键字参数

变量作用域

函数外定义的变量：全局变量； 函数内定义的变量：局部变量

global关键字：定义全局变量

面向对象

1 类

类 = 面向对象

面向对象的核心：1 类 2 对象。 类最基本的作用是封装

定义类的方法：

  1.   class ClassName():
  2.       name = '' #类的内部可以定义变量
  3.       def study(self): #类的内部可以定义函数
  4.           pass

类的实例化：

  1.   student = Sutdent()  #类名+括号实例化并赋值给变量
  2.   student.study()  #实例化的变量可以调用类内部的方法

构造函数： 实例化对象时自动执行， 作用：1 初始化对象属性

类变量 实例变量

  1.   class Student():
  2.       name = ''  #定义在类中，类变量
  3.       def __init__(self,name) :
  4.           sele.name = name   #实例变量

8 模块

9 错误

10 类

11 标准模块介绍

12 虚拟环境和软件包

13 常见第三方模块介绍

2 常用安装

2.1 virtualenv

  1.   1. 安装 `pip3 install virtualenv`
  2.   2. 创建：`virtualenv --no-site-packages venv`
  3.   3. 进入 `source venv/bin/activate`
  4.   4. 退出 ：`deactivate`
  6.   Virtualenv
  7.       • 安装virtualenv ： pip install virtualenv
  8.       • 创建环境testenv： virtualenv --no-site-packages testenv
  9.       • 进入环境  1 win：   testenv\scripts\activate.bat                mac : source testenv/bin/activate
  10.       • 退出环境  1 win : testenv\scripts\deactivate.bat                    2 mac:   decativate
  12.   安装virtualenwrapper
  13.       • 安装 pip install virtualenvwrapper-win
  14.       • 创建环境： mkvirtualenv testenv
  15.       • 列出所有环境： lsvirtualenv
  16.       • 进入 workon testenv
  17.       • 进入虚拟环境site-package目录： cdvirtualenv testenv
  18.       • 停止虚拟环境：deactivate
  19.       • 删除环境： 1 删除目录   2 rmvirtualenv testenv
  20.       • #
  21.       • 冻结环境: pip freeze > packages.txt
  22.       • 重建环境: pip install -r packages.txt
  24.   原文链接：http://www.cnblogs.com/suke99/p/5355894.html

2.2 PIP

  • 安装： 安装python后自带

    pip安装软件

    `` pip install 包名`
  • pip3 install django *
    1. <a name="aemstp"></a>
    2. ### pip卸载软件
    pip uninstall 包名 ```

2.3 链接mysql数据库

MySql数据库驱动

  1. 1. pymysql ：

3 框架

3.1 Django

3.2 Flask