注释

单行注释：# 注释内容
多行注释：’’’ 注释
内容’’’
注意该方法只能用一次，第二次会被当作是字符串，即变量。

变量

变量：用来存储数据的地址名称

声明变量

  1. a = 1
  2. print(a)

变量定义的规则

  • 变量由字母、下划线和数字组合而成
  • 变量不能以数字开头
  • 变量不能与关键字相同：
    • [‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘exec’, ‘finally’,

‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘not’, ‘or’, ‘pass’, ‘print’, ‘raise’, ‘return’, ‘try’,
‘while’, ‘with’, ‘yield’]

  • 变量的定义要能见名知意。

    变量命名的方法

    常见方法：
    骆驼法（开头小写）
    如：printEmployeePaychecks()
    print_employee_paychecks()
    帕斯卡法（与骆驼法相似，只是开头大写）

    变量的赋值

    1. a = "变量1"
    2. b = "变量2"
    ~ZZZ9186NCXIDHE3P9XIERB.png
    1. a = "变量1"
    2. b = a
    ![S6}3J6JA5R{APE14@$M2ZP.png

    程序交互

    输入

    1. student_name = input("请输入用户名：")
    2. student_pwd = input("请输入密码：")

    格式化输出

    1. print("欢迎" + student_name + "来到英格")
    2. print("欢迎%s来到英格" % student_name)
    3. print("欢迎{}来到英格".format(student_name))
    4. print("用户名是{0}，密码是{1}".format(student_name, student_pwd))
    5. print("用户名是{1}，密码是{0}".format(student_name, student_pwd))
    6. print("用户名是{name}，密码是{pwd}".format(name=student_name, pwd=student_pwd))
    结果
    1. 请输入用户名：lisi
    2. 请输入密码：1
    3. 欢迎lisi来到英格
    4. 欢迎lisi来到英格
    5. 欢迎lisi来到英格
    6. 用户名是lisi，密码是1
    7. 用户名是1，密码是lisi
    8. 用户名是lisi，密码是1

    基础数据类型

    整型(int)

    在 32 位机器上，整数的位数为 32 位，取值范围为 -231～231-1，即 -2147483648～2147483647
    在 64 位系统上，整数的位数为 64 位，取值范围为 -263～263-1，即 -9223372036854775808～
    9223372036854775807

注意：在python3中不再有long类型了，全部是int

  1. a = 2**64
  2. print(type(a))    #type()是查看数据类型的方法

运行结果

  1. <class 'int'>

布尔值(True,False)

布尔类型只有两个值，真或假，用于记逻辑判断

  1. a = 3
  2. b = 5
  3. print(a < b, a > b , a != b)

运行结果

  1. True False True

字符串(str)

在python中加了引号的字符都被认为是字符串。

  1. a = "人生苦短，我用python"
  2. b = '''
  3. 欢迎光临
  4. 今天学习python'''
  5. print(a, b)

运行结果

  1. 人生苦短，我用python 
  2. 欢迎光临
  3. 今天学习python

字符串的索引与切片

切片的顾头不顾腚原则：
[a:b] 能取到a，取不到b（取到b-1）

  1. str_a = "ABCDEFGHIJK"
  2. print(str_a[0])
  3. print(str_a[-1])
  4. # 切片，顾头不顾腚原则
  5. print(str_a[0:-1])
  6. # 切片不填默认到最后一个值
  7. print(str_a[:])
  8. print(str_a[2:])
  9. print(str_a[:-4])
  10. print(str_a[-1::-2]) #从最后一个开始到第一个，步长-2
  11. print(str_a[0::2])

运行结果

  1. A
  2. K
  3. ABCDEFGHIJ
  4. ABCDEFGHIJK
  5. CDEFGHIJK
  6. ABCDEFG
  7. KIGECA
  8. ACEGIK

字符串常用方法

  • 字符串拼接

    1. c = 'home '
    2. d = 'welcome '
    3. print(d + c, '*' * 3, d * 3)

    运行结果

    1. welcome home  *** welcome welcome welcome

  • 大小写

    1. words = "life is short, i need python"
    2. print(words.capitalize())
    3. print(words.swapcase())
    4. print(words.title())

    运行结果

    1. Life is short, i need python
    2. LIFE IS SHORT, I NEED PYTHON
    3. Life Is Short, I Need Python

  • 内容居中（总长度，空白处填充）center

    1. a = "test"
    2. ret = a.center(20,"*")
    3. print(ret)

    运行结果

    1. ********test********

  • 统计字符串中的元素出现的个数 count

    1. ret = words.count("e",0,30)
    2. print(ret)

    运算结果

    1. 3

  • 判断字符串的开头和结尾 startwith endwith

    1. a = "aisdjioadoiqwd12313assdj"
    2. print(a.startswith("a"))
    3. print(a.endswith("j"))
    4. print(a.startswith('sdj',2,5))
    5. print(a.endswith('ado',7,10))

    运行结果

    1. True
    2. True
    3. True
    4. True

  • 寻找字符串中的元素 find ```python print(a.find(‘sdj’,1,10)) # 返回的找到的元素的索引，如果找不到返回-1 print(a.index(‘sdj’,1,10)) # 返回的找到的元素的索引，找不到报错。

print(a.find(‘hahah’,1,10)) # 返回的找到的元素的索引，如果找不到返回-1 print(a.index(‘hahaha’,1,10)) # 返回的找到的元素的索引，找不到报错。

  1. 运行结果
  2. ```python
  3. 2
  4. 2
  6. Traceback (most recent call last):
  7.   File "C:/Users/mi/PycharmProjects/untitled/1.py", line 37, in <module>
  8.     print(a.index('hahaha',1,10))  # 返回的找到的元素的索引，找不到报错。
  9. ValueError: substring not found
  10. -1

  • 分割 split

    1. words = "life is short, i need python"
    2. ret = words.split(' ')
    3. print(ret)
    4. ret = words.rsplit(' ',2) #从右往左分割，遇到空格分割一次，共分割两次
    5. print(ret)

    运行结果

    1. ['life', 'is', 'short,', 'i', 'need', 'python']
    2. ['life is short, i', 'need', 'python']

  • 弹出 strip

    1. a = '****asdasdasd********'
    2. print(a.strip('*'))
    3. print(a.lstrip('*'))
    4. print(a.rstrip('*'))

    运行结果

    1. asdasdasd
    2. asdasdasd********
    3. ****asdasdasd

  • 替代 replace

    1. words = "life is short, i need python"
    2. print(words.replace('e','a',2)) # 字符串从左向右开始，把e替换成a，一共替换两次
    3. print(words.isalnum()) #字符串由字母或数字组成
    4. print(words.isalpha()) #字符串只由字母组成
    5. print(words.isdigit()) #字符串只由数字组成

    运行结果

    1. lifa is short, i naed python
    2. False
    3. False
    4. False

    基本运算符

定义a=10,b=20

算术运算

运算符 描述 实例
+ 加 a+b=30
- 减 b-a=10
* 乘 a*b=200
/ 除 b/a=2.0
% 取余 b%a=0
** 幂 a**b=100000000000000000000
// 取整 b//a=2

比较运算

运算符 描述 实例
== 等于，比较两个值是否相等 (a == b)返回False
!= 不等于，比较两个值是否不等 (a != b)返回True
<> 不等于，比较两个值是否不等 (a <> b)返回True
> 大于，比较x是否大于y (a > b)返回False
< 小于，比较x是否小于y (a < b)返回True
>= 大于等于 (a>= b)返回False
<= 小于等于 (a <= b)返回True

逻辑运算

运算符 描述 实例
and 与运算，全部为真才为真，否则为假 (a and b)返回true
or 或运算，有一个为真则为真 (a or b)返回true
not 非运算，真返回假，假返回真 not(a and b)返回false

运算符优先级

运算符 描述
** 指数
~+- 按位反转，一元加号和减号
*/%// 乘，除，取余和取整除
+- 加法和减法
>><< 右移和左移
& 位’And’
^ 位运算符
><>=<= 比较运算符
<>==!= 等于运算符
=，+=，-=，*= 赋值运算符
is，is not 身份运算符
in，not in 成员运算符
not and or 逻辑运算符

python数据类型

元组 tuple

元组又可以成为只读列表，即数据可以被查询，但是不能被修改。

列表 list

列表可以存储大量不同类型的数据，列表是有序的，有索引值，可切片，方便取值。

增

  1. list1 = [1, 'a', 2, 'b', 3, 'c']
  2. list1.insert(0, 'hello')    #指定位置插入
  3. print(list1)
  4. list1.append('world')    #增加到最后
  5. print(list1)
  6. list1.extend(['q,a,w'])
  7. print(list1)
  8. list1.extend(['q,a,w', 'das'])    #迭代增加到最后
  9. print(list1)

运行结果

  1. ['hello', 1, 'a', 2, 'b', 3, 'c']
  2. ['hello', 1, 'a', 2, 'b', 3, 'c', 'world']
  3. ['hello', 1, 'a', 2, 'b', 3, 'c', 'world', 'q,a,w']
  4. ['hello', 1, 'a', 2, 'b', 3, 'c', 'world', 'q,a,w', 'q,a,w', 'das']

删

  1. list1 = [1, 'a', 2, 'b', 3, 'c']
  2. list1.pop(1)    #按位置删除，有返回值
  3. print(list1)
  4. del(list1[2:4])    #按位置删除，可以切片删除，无返回值
  5. print(list1)
  6. list1.remove('c')    #删除指定元素
  7. print(list1)
  8. list1.clear()    #清空列表
  9. print(list1)

运行结果

  1. [1, 2, 'b', 3, 'c']
  2. [1, 2, 'c']
  3. [1, 2]
  4. []

改

  1. list1 = [1, 'a', 2, 'b', 3, 'c']
  2. list1[1] = 'aaa'
  3. print(list1)
  4. list1[2:3] = [22, 'e']    #列表的第三个元素改为22和'e'两个元素，其后的元素往后顺移
  5. print(list1)

运行结果

  1. [1, 'aaa', 2, 'b', 3, 'c']
  2. [1, 'aaa', 22, 'e', 'b', 3, 'c']

查

查询的两个方法：切片或者循环

  1. list1 = [1, 'a', 2, 'b', 3, 'c']
  2. print(list1[0])
  3. print(list1[0:2])
  4. for i in range(6):
  5.     print(list1[i])

运行结果

  1. 1
  2. [1, 'a']
  3. 1
  4. a
  5. 2
  6. b
  7. 3
  8. c

其他操作

  1. list2 = [0, 1, 2, 3, 4, 4, 5, 3, 2, 7]
  2. print(list2.count(4))    #计算元素在列表中共出现几次
  3. print(list2.index(1))    #从左往右索引元素第一次在列表中出现的位置
  4. list2.sort()    #将列表排序，从左往右由小到大
  5. print(list2)
  6. list2.reverse()    #将列表中的元素反向存放
  7. print(list2)

运行结果

  1. 2
  2. 1
  3. [0, 1, 2, 2, 3, 3, 4, 4, 5, 7]
  4. [7, 5, 4, 4, 3, 3, 2, 2, 1, 0]

字典 dict

字典是python中唯一的映射类型，采用键值对(key - value)存储数据。python对key进行哈希运算得到value的存储地址，这表示key必须要是可哈希的，即key是不可变类型如数字、字符串、元组。
python3.5 以前字典是无序的，之后字典变成有序的了，要了解原因得要先了解字典的存储方式。

  • python3.5之前

当我们初始化一个空字典时，CPython会在底层初始化一个二维数组，这个数组有8行，3列，如下面示意图所示：

  1. my_dict = {}
  3. '''
  4. [[---,---,---]
  5.  [---,---,---]
  6.  [---,---,---]
  7.  [---,---,---]
  8.  [---,---,---]
  9.  [---,---,---]
  10.  [---,---,---]
  11.  [---,---,---]]
  12.  '''

现在我们往这个空字典里加入一条数据

  1. mt_dict['name'] = {'python'}
  4. #此时内存如下
  5. '''
  6. [[---,---,---]
  7.  [---,---,---]
  8.  [---,---,---]
  9.  [-3219953380708220565,指向'name'的指针,指向'python'的指针]
  10.  [---,---,---]
  11.  [---,---,---]
  12.  [---,---,---]
  13.  [---,---,---]]
  14.  '''

这里要解释一下为什么内存是这样的，首先我们添加了一条键值对 ‘name’:’python’ ，然后python对这条键值对的key进行哈希运算

  1. print(hash('name'))
  2. -3219953380708220565

然后将哈希运算后得到的值除8取余得到3

  1. print(hash('name') % 8)
  2. 3

所以在二维数组的下标为3的那一行存储数据，第一列存放键的哈希值，第二列存放指向键的指针，第三列存放指向值的指针。
由于python里的hash函数只在每一个运行时保持不变，不同运行时的运算结果都可能改变，这就导致由哈希值运算得到的键值对的存储位置每一个运行时都可能不同，所以字典是无序的。

  • python3.5之后

当我们初始化一个空字典时，python会初始化两个数组，一个长度为8一维数组，一个空的二维数组。

  1. my_dict = {}
  3. #此时内存示意图
  4. '''
  5. indices = [None,None,None,None,None,None,None,None]
  7. entries = []
  8. '''

这之后我们添加一条数据

  1. my_dict['name'] = {'python'}
  3. #此时内存示意图
  4. '''
  5. indices = [None,None,None,0,None,None,None,None]
  7. entries = [[-3219953380708220565,指向'name'的指针,指向'python'的指针]]
  8. '''

内存会是这样是因为，对’name’运算后哈希值为-3219953380708220565，哈希值%8得到3，于是一维数组下标为3的位置存入0，而在二维数组下标0的位置存入键值对相对应的数据。
打个比方，一维数组是值班室，二维数组是仓库，要把货物存放进仓库，首先要去值班室登记，去那个值班室是随机的（哈希运算key得到）。假设来了一个货物，到值班室登记第一个货物到达，然后去第一个仓库把货物存进去；第二个货物来了，随机去一个值班室登记第二个货物到达，然后去第二个仓库把货物存进去，往后以此类推。

这样做的好处是哪怕每一个运算时对key的哈希运算值不一样，改变的也只是一维数组的顺序，二维数组是按照键值对插入的次序排的，次序不会改变，即字典是有序的。

增

  1. dic = {"age":18, "name":"aaron"}
  2. dic['li'] = ["a","b","c"]
  3. print(dic)
  5. #向字典中添加键值对，如果只有键则值默认为none，如果字典中已存在要添加的键则他不会更改或覆盖
  6. dic.setdefault('k','v')
  7. print(dic)
  8. dic.setdefault('k','v1')
  9. print(dic)

运行结果

  1. {'age': 18, 'name': 'aaron', 'li': ['a', 'b', 'c']}
  2. {'age': 18, 'name': 'aaron', 'li': ['a', 'b', 'c'], 'k': 'v'}
  3. {'age': 18, 'name': 'aaron', 'li': ['a', 'b', 'c'], 'k': 'v'}

删

  1. # pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
  2. dic = {"age":18, "name":"aaron"}
  3. dic_pop = dic.pop('age')
  4. print(dic_pop)
  5. dic_pop = dic.pop('sex','查无此项')
  6. print(dic_pop)
  8. #运行结果
  9. 18
  10. 查无此项
  12. ##########################
  13. dic['age'] = 18
  14. print(dic)
  15. del dic['name']
  16. print(dic)
  18. #运行结果
  19. {'name': 'aaron', 'age': 18}
  20. {'age': 18}
  22. ##########################
  23. dic['name'] = 'demo'
  25. #随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回
  26. dic_pop = dic.popitem()
  27. print(dic_pop)
  29. #清空字典
  30. dic_clear = dic.clear()
  31. print(dic,dic_clear)
  33. #运行结果
  34. ('name', 'demo')
  35. {} None

改

  1. dic = {"age":18, "name":"aaron", 'sex':'male'}
  2. dic2 = {"age":30, "name":'demo'}
  4. dic2.update(dic)
  5. # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
  6. print(dic2)
  8. dic2['age'] = 30
  9. print(dic2)
  11. #运行结果
  12. {'age': 18, 'name': 'aaron', 'sex': 'male'}
  13. {'age': 30, 'name': 'aaron', 'sex': 'male'}

查

  1. dic = {"age":18, "name":"aaron", 'sex':'male'}
  2. value = dic['name']
  3. print(value)
  4. # 没有对应的键值对会报错
  6. value = dic.get('abc','查无此项')
  7. print(value)
  9. #运行结果
  10. aaron
  11. 查无此项

其他操作

  1. dic = {"age":18, "name":"aaron", 'sex':'male'}
  2. for i in dic.items():
  3.     # 将键和值作为元祖列出
  4.     print(i)
  6. #运行结果
  7. ('age', 18)
  8. ('name', 'aaron')
  9. ('sex', 'male')
  10. ######################################
  11. for key,value in dic.items():
  12.     print(key,value)
  14. #运行结果
  15. age 18
  16. name aaron
  17. sex male
  18. #######################################
  19. for i in dic:
  20.     # 只是迭代键
  21.     print(i)
  23. #运行结果
  24. age
  25. name
  26. sex
  27. #######################################
  28. keys = dic.keys()
  29. print(keys,type(keys))
  30. value = dic.values()
  31. print(value,type(value))
  33. #运行结果
  34. dict_keys(['age', 'name', 'sex']) <class 'dict_keys'>
  35. dict_values([18, 'aaron', 'male']) <class 'dict_values'>

集合 set

集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希
（所以集合做不了字典的键）的。以下是集合最重要的两点：

  • 去重，把一个表变成集合就自动去重了
  • 关系测试，测试两组数据之前的交集、差集、并集等关系。

    创建集合

    1. set1 = set({1,2,'barry'})
    2. set2 = {1,2,'barry'}

    增

    s.add( x )

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
add添加的是哈希数据类型（不可变），如整型、元组、字符串。且add不会影响集合中已有的元素，例如集合中已有a，在add添加a集合中最后也只有一个a。

s.update( x )

x 可以有多个，用逗号分开。
update添加的是可迭代的数据类型，如字符串、元组、列表、字典和集合。添加方法是分解成字符。

  1. set1 = {'abc','def',123,'asdas'}
  2. set1.add('qwer')
  3. print(set1)
  4. set1.update('A')
  5. #update：迭代着增加
  6. print(set1)
  7. set1.update('哈哈哈')
  8. print(set1)
  9. set1.update([1,2,3])
  10. print(set1)
  12. #运行结果
  13. {'asdas', 'abc', 'def', 'qwer', 123}
  14. {'asdas', 'A', 'abc', 'def', 'qwer', 123}
  15. {'asdas', '哈', 'A', 'abc', 'def', 'qwer', 123}
  16. {1, 'asdas', '哈', 2, 3, 'A', 'abc', 'def', 'qwer', 123}

删

  1. set1 = {'abc','def',123,'asdas'}
  2. set1.remove('abc')
  3. print(set1)
  4. #运行结果
  5. {'asdas', 123, 'def'}
  7. # 随机删除一个数
  8. set1.pop()
  9. print(set1)
  10. #运行结果
  11. {123, 'def'}
  13. # 清空合集
  14. set1.clear()
  15. print(set1)
  16. set()
  18. # 删除合集
  19. del set1
  20. print(set1)
  21. #运行结果
  22. Traceback (most recent call last):
  23.   File "C:/Users/mi/PycharmProjects/untitled/1.py", line 118, in <module>
  24.     print(set1)
  25. NameError: name 'set1' is not defined

其他操作

交集（& 或者 intersection）

  1. set1 = {1,2,3,4,5}
  2. set2 = {3,4,5,6,7}
  3. print(set1 & set2)
  4. print(set1.intersection(set2))
  5. # 列出两个集合中共同拥有的项

并集（| 或者 union）

  1. set1 = {1,2,3,4,5}
  2. set2 = {3,4,5,6,7}
  3. print(set1 | set2)
  4. print(set2.union(set1))
  5. # 列出两个集合中所有的项

差集（- 或者 difference）

  1. set1 = {1,2,3,4,5}
  2. set2 = {3,4,5,6,7}
  3. print(set1 - set2)
  4. print(set1.difference(set2))
  5. # 在set1中删除set2中有的项

反交集 （^ 或者 symmetric_difference）

  1. set1 = {1,2,3,4,5}
  2. set2 = {3,4,5,6,7}
  3. print(set1 ^ set2)
  4. print(set1.symmetric_difference(set2))
  5. # 显示set1和set2不共存的项

子集与超集

  1. set1 = {1,2,3}
  2. set2 = {1,2,3,4,5,6}
  3. print(set1 < set2)
  4. print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。
  5. print(set2 > set1)
  6. print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集

不可变集合（frozenset让集合变成不可变类型）

  1. set1 = {1,2,3,4,5,6}
  2. s = frozenset(set1)
  3. print(s,type(s))
  4. s.add(7) # 不可以修改,会报错

流程控制

if

~5W2PVBYC`@NV1$A{J$G0C8.png

  • 单分支

    1. if条件:
    2.   满足条件后要执行的代码

  • 双分支

    1. if 条件:
    2.   满足条件后执行的代码
    3. else:
    4.   if条件不满足执行的代码

    if … else …可以有多个分支

    1. if 条件:
    2.   满足条件执行代码
    3. elif 条件:
    4.   上面的条件不满足就走这个
    5. elif 条件:
    6.   上面的条件不满足就走这个
    7. elif 条件:
    8.   上面的条件不满足就走这个    
    9. else:
    10.   上面所有的条件不满足就走这段

    while

    基本循环

    1. while 条件:
    2.   循环体

    如果条件为真，则循环体执行
    如果条件为假，则循环体不执行

    1. print('猜数字游戏开始')
    2. num = 54
    3. while True:
    4.   guess = int(input("您猜数字是什么？(输入0-100的数字)"))
    5.   if guess < num:
    6.       print("您猜小了")
    7.       continue
    8.   elif guess > num:
    9.       print("您猜大了")
    10.       continue
    11.   break
    12. print("您猜对了！")

    运行结果

    1. 猜数字游戏开始
    2. 您猜数字是什么？(输入0-100的数字)50
    3. 您猜小了
    4. 您猜数字是什么？(输入0-100的数字)60
    5. 您猜大了
    6. 您猜数字是什么？(输入0-100的数字)54
    7. 您猜对了！

    循环终止语句

    break

    用于完全结束一个循环，跳出循环体执行循环后面的语句

    continue

    和 break 有点类似，区别在于 continue 只是终止本次循环，接着还执行后面的循环

    while … else …

    while 后面的 else 作用是指，当 while 循环正常执行完（while的条件为假了），中间没有被 break 中止的话，就会执行 else 后面的语句

    其他（for，enumerate，range）

    for循环：用户按照顺序循环可迭代对象的内容。

    1. s = '先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。'
    2. for i in s:
    3.   print(i)
    4. li = ['甲','乙','丙','丁']
    5. for i in li:
    6.   print(i)
    7. dic = {'a':1,'b':2,'c':3}
    8. for k,v in dic.items():
    9.   print(k,v)

    enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将
    其组成一个索引序列，利用它可以同时获得索引和值。 ```python li = [‘甲’,’乙’,’丙’,’丁’] for i in li: print(i) for i in enumerate(li): print(i) for index,value in enumerate(li): print(index,value) for index,value in enumerate(li,100): #从哪个数字开始索引 print(index,value)

运行结果

甲 乙 丙 丁 (0, ‘甲’) (1, ‘乙’) (2, ‘丙’) (3, ‘丁’) 0 甲 1 乙 2 丙 3 丁 100 甲 101 乙 102 丙 103 丁

  1. range：指定范围，生成指定数字。
  2. ```python
  3. for i in range(1,10):
  4.     print(i)
  5. for i in range(1,10,2):  # 步长
  6.     print(i)
  7. for i in range(10,1,-2): # 反向步长
  8.     print(i)