资料
（廖雪峰）https://www.liaoxuefeng.com/wiki/1016959663602400/1017063826246112
（笨办法）https://www.kancloud.cn/kancloud/learn-python-hard-way/49892

语法规则
https://www.jianshu.com/p/a793c0d960fe

常见问题

我可以用单引号或双引号标识一个字符串，那它们有什么不同吗?

在Python中，单双引号都可以用来标识一个字符串，单引号更多用在较短的字符串上。

Shell echo命令

Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式：

  2. 用来标注环境
  3. #!/usr/bin/env python3
  4. # -*- coding: utf-8 -*-
  6. # https://www.runoob.com/python3/python-func-print.html
  7. # https://www.runoob.com/w3cnote/python3-print-func-b.html  使用样历
  8. print()语法，最后会自动换行

数组

  1. List（列表） 是 Python 中使用最频繁的数据类型。
  3. 列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
  5. 列表用 [ ] 标识，是 python 最通用的复合数据类型。
  7. 列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
  9. list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
  10. tinylist = [123, 'john']
  12. print list               # 输出完整列表
  13. print list[0]            # 输出列表的第一个元素
  14. print list[1:3]          # 输出第二个至第三个元素 
  15. print list[2:]           # 输出从第三个开始至列表末尾的所有元素
  16. print tinylist * 2       # 输出列表两次
  17. print list + tinylist    # 打印组合的列表
  18. ['runoob', 786, 2.23, 'john', 70.2]
  19. runoob
  20. [786, 2.23]
  21. [2.23, 'john', 70.2]
  22. [123, 'john', 123, 'john']
  23. ['runoob', 786, 2.23, 'john', 70.2, 123, 'john']
  1. Python 元组   =  只读列表
  3. 元组是另一个数据类型，类似于 List（列表）。
  5. 元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
  7. tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
  8. tinytuple = (123, 'john')
  10. print tuple               # 输出完整元组
  11. print tuple[0]            # 输出元组的第一个元素
  12. print tuple[1:3]          # 输出第二个至第四个（不包含）的元素 
  13. print tuple[2:]           # 输出从第三个开始至列表末尾的所有元素
  14. print tinytuple * 2       # 输出元组两次
  15. print tuple + tinytuple   # 打印组合的元组
  1. 字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。
  3. 两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
  5. 字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
  7. dict = {}
  8. //存数据
  9. dict['one'] = "This is one"
  10. dict[2] = "This is two"
  12. tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
  15. print dict['one']          # 输出键为'one' 的值
  16. print dict[2]              # 输出键为 2 的值
  17. print tinydict             # 输出完整的字典
  18. print tinydict.keys()      # 输出所有键
  19. print tinydict.values()    # 输出所有值
  21. 删除字典的元素
  22. dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
  24. del dict['Name']  # 删除键是'Name'的条目
  25. dict.clear()      # 清空字典所有条目
  26. del dict          # 删除字典
  28. 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行
  31. #!/usr/bin/python
  33. dict = {['Name']: 'Zara', 'Age': 7} 
  35. print "dict['Name']: ", dict['Name']

数组常用
https://www.runoob.com/python/python-lists.html
image.png

判断条件

  1. if num >= 0 and num <= 10:    # 判断值是否在0~10之间
  2.     print 'hello'
  3. # 输出结果: hello
  5. num = 10
  6. if num < 0 or num > 10:    # 判断值是否在小于0或大于10
  7.     print 'hello'
  8. else:
  9.     print 'undefine'

循环

  1. Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
  4. for letter in 'Python':     # 第一个实例
  5.    print '当前字母 :', letter
  7. fruits = ['banana', 'apple',  'mango']
  8. for fruit in fruits:        # 第二个实例
  9.    print '当前水果 :', fruit
  11. print "Good bye!"
  13. fruits = ['banana', 'apple',  'mango']
  14. for index in range(len(fruits)):
  15.    print '当前水果 :', fruits[index]
  17. print "Good bye!"

Python pass 是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句。
该处的 pass 便是占据一个位置，因为如果定义一个空函数程序会报错，当你没有想好函数的内容是可以用 pass 填充，使程序可以正常运行。

  1. 数学计算
  2. + plus 加号 
  3. - minus 减号
  4. / slash 斜杠 除法
  5. * asterisk 星号 乘法
  6. % percent 百分号 模除
  7. < less-than 小于号
  8. > greater-than 大于号
  9. <= less-than-equal 小于等于号
  10. >= greater-than-equal 大于等于号
  12. >>> 7/4
  13. 1.75
  15. >>> 7 % 4
  16. 3

动态语言是指运行期间可以改变其结构的语言

  1. Q: 为什么for i in range(1, 3):只循环了两次？
  2.     range()函数循环的次数不包括最后一个。所以range(1,3)只循环到2,这是这种循环最常用的方法。
  6.              the_count = [1, 2, 3, 4, 5] 
  8.       for number in the_count:
  9.         print("This is count %d" % number)
  11.      会把1，2，3，4，5 全部打印出来
  1. 数组 https://www.runoob.com/python/python-variable-types.html
  2. animals = ['bear', 'tiger', 'penguin', 'zebra']
  3. bear = animals[0]
  5. 数组切割
  6. >>> s = 'abcdef'
  7. >>> s[1:5]
  8. 'bcde'
  11. 数组 用 []

对象

https://www.runoob.com/python/python-object.html

  1. #!/usr/bin/python
  2. # -*- coding: UTF-8 -*-
  4. class Employee:
  5.    '所有员工的基类'
  6.    empCount = 0
  7.  #__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
  8.    def __init__(self, name, salary):
  9.       self.name = name
  10.       self.salary = salary
  11.       Employee.empCount += 1
  12.    #self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。
  13.    def displayCount(self):
  14.      print "Total Employee %d" % Employee.empCount
  16.    def displayEmployee(self):
  17.       print "Name : ", self.name,  ", Salary: ", self.salary
  21. 执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.__class__ 则指向类
  1. getattr(obj, name[, default]) : 访问对象的属性。
  2. hasattr(obj,name) : 检查是否存在一个属性。
  3. setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
  4. delattr(obj, name) : 删除属性。
  5. hasattr(emp1, 'age')    # 如果存在 'age' 属性返回 True。
  6. getattr(emp1, 'age')    # 返回 'age' 属性的值
  7. setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8
  8. delattr(emp1, 'age')    # 删除属性 'age'
  1. 单下划线、双下划线、头尾双下划线说明：
  2. __foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。
  4. _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
  6. __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。
  9. Python不允许实例化的类访问私有数据,但你可以使用 
  10. object._className__attrName（ 对象名._类名__私有属性名 ）访问属性
  11. #!/usr/bin/python
  12. # -*- coding: UTF-8 -*-
  14. class Runoob:
  15.     __site = "www.runoob.com"
  17. runoob = Runoob()
  18. print runoob._Runoob__site
  1. # 可写函数说明
  2. sum = lambda arg1, arg2: arg1 + arg2
  4. # 调用sum函数
  5. print "相加后的值为 : ", sum( 10, 20 )
  6. print "相加后的值为 : ", sum( 20, 20 )

grobal

每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。
Python 会智能地猜测一个变量是局部的还是全局的，它假设任何在函数内赋值的变量都是局部的。
因此，如果要给函数内的全局变量赋值，必须使用 global 语句。
global VarName 的表达式会告诉 Python， VarName 是一个全局变量，这样 Python 就不会在局部命名空间里寻找这个变量了。