Python基础语法.ipynb

注：下载附件ipynb文件到之前创建的da_learn文件，并在da_learn运行jupyter-lab.exe，点击打开即可进行交互式学习和练习哦！

mementopython3-english.pdf

1. 注释

注释就是告诉计算机，这行文字只是普通说明文字，不用执行

  1. # 开头的是单行注释
  3. """ 
  4. 多行字符串用三个引号
  5. 包裹，也常被用来做多
  6. 行注释
  7. """
  9. pass # 这行是空语句，一般用来占用一行备用或啥也不是
  11. a = 1 # 变量定义并赋值
  13. name="QQ" # 变量定义并赋值
  15. print("hello world!") # 打印函数，用于将传入的参数打印出来，以便观察
  17. print("hello %s!" % name) # 打印函数的参数格式化，以便动态修改打印的文字
  1. hello world!
  2. hello QQ!

2.基础数据类型和运算符

  1. """
  2. 1. 数值运算: 
  3. +  加
  4. -  减
  5. *  乘
  6. /  除
  7. // 取整除
  8. %  模运算
  9. ** 乘方
  11. 2. 逻辑运算
  12. and 与
  13. or  或
  14. not 非
  15. >   大于
  16. >=  大于或等于
  17. <   小于
  18. <=  小于或等于
  20. 3. 字符串格式化
  21. + 拼接
  22. [num] 索引
  23. % 格式化
  24.     %s    字符串 (采用str()的显示)
  26.     %r    字符串 (采用repr()的显示)
  28.     %c    单个字符
  30.     %b    二进制整数
  32.     %d    十进制整数
  34.     %i    十进制整数
  36.     %o    八进制整数
  38.     %x    十六进制整数
  40.     %e    指数 (基底写为e)
  42.     %E    指数 (基底写为E)
  44.     %f    浮点数
  46.     %F    浮点数，与上相同
  48.     %g    指数(e)或浮点数 (根据显示长度)
  50.     %G    指数(E)或浮点数 (根据显示长度)
  52.     %%    字符"%"
  54. format格式化
  55.     "{} is a {}!".format("God", "girl")
  57. """
  58. pass
  1. # 整数运算
  3. a = 5 + 3 # 加
  4. print("5 + 3 = %d" % a)
  6. b = 5 - 3 # 减
  7. print("5 - 3 = %d" % b)
  9. c = 5 * 3 # 乘
  10. print("5 * 3 = %d" % c)
  12. d = 5 / 3 # 除
  13. print("5 / 3 = %d" % d)
  15. e = 5 // 3 # 除
  16. print("5 // 3 = %d" % e)
  18. f = 5 % 3 # 模运算
  19. print("5 %% 3 = %d" % f)
  21. g = 5 ** 3 # 乘方运算
  22. print("5 %% 3 = %d" % g)
  24. h = 5 * (2 + 1) - 1 # 优先级运算
  25. print("5 * (2 + 1) - 1 = %d" % h)
  1. 5 + 3 = 8
  2. 5 - 3 = 2
  3. 5 * 3 = 15
  4. 5 / 3 = 1
  5. 5 // 3 = 1
  6. 5 % 3 = 2
  7. 5 % 3 = 125
  8. 5 * (2 + 1) - 1 = 14
  1. # 浮点运算
  3. a = 5.0 + 3 # 加
  4. print("5.0 + 3 = %.2f" % a)
  6. b = 5.0 - 3 # 减
  7. print("5.0 - 3 = %.2f" % b)
  9. c = 5.0 * 3 # 乘
  10. print("5.0 * 3 = %.2f" % c)
  12. d = 5.0 / 3 # 除
  13. print("5.0 / 3 = %.2f" % d)
  15. e = 5.0 // 3 # 除
  16. print("5.0 // 3 = %.2f" % e)
  18. f = 5.0 % 3 # 模运算
  19. print("5.0 %% 3 = %.2f" % f)
  21. g = 5.0 ** 3 # 乘方运算
  22. print("5.0 %% 3 = %.2f" % g)
  24. h = 5.0 * (2 + 1) - 1 # 优先级运算
  25. print("5.0 * (2 + 1) - 1 = %.2f" % h)
  1. 5.0 + 3 = 8.00
  2. 5.0 - 3 = 2.00
  3. 5.0 * 3 = 15.00
  4. 5.0 / 3 = 1.67
  5. 5.0 // 3 = 1.00
  6. 5.0 % 3 = 2.00
  7. 5.0 % 3 = 125.00
  8. 5.0 * (2 + 1) - 1 = 14.00
  1. # 布尔值 与 逻辑运算
  3. # True False
  4. print("True:  %s" % True)
  5. print("False: %s" % False)
  7. a = True and True
  8. print("True and True:  %s" % a)
  10. b = True and False
  11. print("True and False:  %s" % b)
  13. c = False and True
  14. print("False and True:  %s" % c)
  16. d = False and False
  17. print("False and False:  %s" % d)
  19. not_true = not True
  20. print("not True:  %s" % not_true)
  22. not_false = not False
  23. print("not False: %s" % not_false)
  25. e = 1 == 1
  26. print("1 == 1: %s" % e)
  28. f = 1 != 1
  29. print("1 != 1: %s" % f)
  31. g = 1 == True
  32. print("1 == True: %s" % g)
  34. h = 1 != True
  35. print("1 != True: %s" % h)
  37. i = 0 == False
  38. print("0 == False: %s" % i)
  40. j = 0 != False
  41. print("0 != False: %s" % j)
  43. k = 5 > 3
  44. print("5 > 3: %s" % k)
  46. l = 5 >= 3
  47. print("5 >= 3: %s" % l)
  49. m = 3 < 5
  50. print("3 < 5: %s" % m)
  52. n = 3 <= 5
  53. print("3 <= 5: %s" % n)
  1. True:  True
  2. False: False
  3. True and True:  True
  4. True and False:  False
  5. False and True:  False
  6. False and False:  False
  7. not True:  False
  8. not False: True
  9. 1 == 1: True
  10. 1 != 1: False
  11. 1 == True: True
  12. 1 != True: False
  13. 0 == False: True
  14. 0 != False: False
  15. 5 > 3: True
  16. 5 >= 3: True
  17. 3 < 5: True
  18. 3 <= 5: True
  1. # 字符串运算
  3. a = "hello"
  4. b = " "
  5. c = "world"
  6. d = "!"
  7. s1 = a + b + c + d
  8. print("s1 = %s" % s1)
  10. e = s[0]
  11. f = s[4]
  12. g = s[-1]
  13. print("e = %s\nf = %s\ng = %s" % (e, f, g))
  15. s2 = "%s%s%s%s" % (a, b, c, d)
  16. print("s2 = %s" % s2)
  18. s3 = "{}{}{}{}".format(a, b, c, d)
  19. print("s3 = %s" % s3)
  21. s4 = "{0} {0}{1}{2}{3}".format(a, b, c, d)
  22. print("s4 = %s" % s4)
  1. s1 = hello world!
  2. e = h
  3. f = o
  4. g = !
  5. s2 = hello world!
  6. s3 = hello world!
  7. s4 = hello hello world!

3. 集合运算

  1. # 列表 可改变的序列
  3. # 定义一个空列表
  4. ls = []
  5. print("空列表ls:", ls)
  7. # 定义一个非空列表
  8. ls = [1, 2, 3, 4, 5, 6, 7, 8, 9]
  9. print("非空列表ls:", ls)
  10. print("列表长度 ls:", len(ls))
  12. # 列表追加元素
  13. ls.append(10)
  14. print("列表追加元素后 ls:", ls)
  16. # 从列表末尾删除元素
  17. ls.pop()
  18. print("从列表末尾删除元素后 ls:", ls)
  20. # 按照索引获取列表元素
  21. print("ls 第1个元素:", ls[0])
  22. print("ls 第2个元素:", ls[1])
  23. print("ls 最后1个元素:", ls[-1])
  25. # 越界访问列表元素
  26. # ls[4]
  28. # 切片
  29. a = ls[0:5]
  30. print("ls 切片[0:5]:", a)
  32. b = ls[:5]
  33. print("ls 切片[:5]:", b)
  35. c = ls[5:9]
  36. print("ls 切片[5:9]:", c)
  38. c = ls[5:]
  39. print("ls 切片[5:]:", c)
  41. d = ls[5:-1]
  42. print("ls 切片[5:-1]:", d)
  44. e = ls[0:5:1]
  45. print("ls 切片[0:5:1]:", e)
  47. f = ls[0:5:2]
  48. print("ls 切片[0:5:2]:", f)
  50. del ls[5]
  51. print("ls 删除第6个元素:", ls)
  53. ls1 = [1, 2]
  54. ls2 = [3, 4]
  55. ls3 = ls1 + ls2
  56. print("列表拼接 ls3:", ls3)
  58. ls1.extend(ls2)
  59. print("列表扩展 ls1:", ls1)
  61. is_in_list = 4 in ls3
  62. print("判断元素是否在列表中 4 in ls3:", is_in_list)
  63. #
  1. 空列表ls: []
  2. 非空列表ls: [1, 2, 3, 4, 5, 6, 7, 8, 9]
  3. 列表长度 ls: 9
  4. 列表追加元素后 ls: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  5. 从列表末尾删除元素后 ls: [1, 2, 3, 4, 5, 6, 7, 8, 9]
  6. ls 第1个元素: 1
  7. ls 第2个元素: 2
  8. ls 最后1个元素: 9
  9. ls 切片[0:5]: [2, 3, 4, 5]
  10. ls 切片[:5]: [1, 2, 3, 4, 5]
  11. ls 切片[5:9]: [6, 7, 8, 9]
  12. ls 切片[5:]: [6, 7, 8, 9]
  13. ls 切片[5:-1]: [6, 7, 8]
  14. ls 切片[0:5:1]: [1, 2, 3, 4, 5]
  15. ls 切片[0:5:2]: [1, 3, 5]
  16. ls 删除第6个元素: [1, 2, 3, 4, 5, 7, 8, 9]
  17. 列表拼接 ls3: [1, 2, 3, 4]
  18. 列表扩展 ls1: [1, 2, 3, 4]
  19. 判断元素是否在列表中 4 in ls3: True
  1. # 元组 不可改变的序列
  3. tup = (1, 2, 3, 4, 5, 6, 7, 8, 9)
  5. # 元组一旦生成则内部元素不可改变
  6. # tup[0] = 0
  8. print("tup 长度:", len(tup))
  9. print("tup 第1个元素:", tup[0])
  10. print("tup 最后1个元素:", tup[-1])
  12. a = tup[0:5]
  13. print("tup 切片[0:5]:", a)
  15. tup1 = (1, 2)
  16. tup2 = (3, 4)
  17. tup3 = tup1 + tup2
  18. print("切片拼接 tup3:", tup3)
  20. is_in_tup = 4 in tup3
  21. print("判断元素是否在元组中 4 in tup3:", is_in_tup)
  23. a, b, c, d = tup3
  24. print("解构元素 a: %d, b: %d, c: %d, d:%d" % ( a, b, c, d))
  1. tup 长度: 9
  2. tup 第1个元素: 1
  3. tup 最后1个元素: 9
  4. tup 切片[0:5]: (1, 2, 3, 4, 5)
  5. 切片拼接 tup3: (1, 2, 3, 4)
  6. 判断元素是否在元组中 4 in tup3: True
  7. 解构元素 a: 1, b: 2, c: 3, d:4
  1. # 字典 键值对数据结构
  3. empty_dict = {}
  4. print("空字典：", empty_dict)
  6. filled_dict = {"one": 1, "two": 2, "three": 3}
  7. print("非空字典：", filled_dict)
  9. a = filled_dict["one"]
  10. print('字典取值 filled_dict["one"]:', a)
  12. b = filled_dict.get("one")
  13. print('字典取值 filled_dict.get("one"):', b)
  15. # flled_dict["nine"] # 获取不存在的键值会报错
  17. c = filled_dict.get("nine")
  18. print('字典取值 filled_dict.get("nine"):', c)
  20. d = filled_dict.get("nine", 9)
  21. print('字典取值 filled_dict.get("nine", 9):', d)
  23. filled_dict["four"] = 4
  24. print('字典插入新的键值对 filled_dict["four"]:', filled_dict)
  26. filled_dict.setdefault("five", 5)
  27. print('字典插入新的键值对 filled_dict.setdefault("five", 5):', filled_dict)
  29. filled_dict.setdefault("five", 0)
  30. print('字典插入新的键值对 filled_dict.setdefault("five", 0):', filled_dict)
  32. del filled_dict["four"]
  33. del filled_dict["five"]
  34. print('字典删除键值对 filled_dict:', filled_dict)
  36. m = {"four": 4, "five": 5}
  37. filled_dict.update(m)
  38. print('字典更新 filled_dict:', filled_dict)
  40. is_in_dict = "nine" in filled_dict
  41. print('判断是否在字典中:', is_in_dict)
  43. keys = filled_dict.keys()
  44. print('字典中的所有键(key):', keys)
  46. values = filled_dict.values()
  47. print('字典中的所有值(value):', values)
  1. 空字典： {}
  2. 非空字典： {'one': 1, 'two': 2, 'three': 3}
  3. 字典取值 filled_dict["one"]: 1
  4. 字典取值 filled_dict.get("one"): 1
  5. 字典取值 filled_dict.get("nine"): None
  6. 字典取值 filled_dict.get("nine", 9): 9
  7. 字典插入新的键值对 filled_dict["four"]: {'one': 1, 'two': 2, 'three': 3, 'four': 4}
  8. 字典插入新的键值对 filled_dict.setdefault("five", 5): {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}
  9. 字典插入新的键值对 filled_dict.setdefault("five", 0): {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}
  10. 字典删除键值对 filled_dict: {'one': 1, 'two': 2, 'three': 3}
  11. 字典更新 filled_dict: {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}
  12. 判断是否在字典中: False
  13. 字典中的所有键(key): dict_keys(['one', 'two', 'three', 'four', 'five'])
  14. 字典中的所有值(value): dict_values([1, 2, 3, 4, 5])
  1. # 集合
  2. empty_set = set()
  3. print("空集合:", empty_set)
  5. filled_set = {1, 2, 3, 4, 5, 4, 3, 2, 1}
  6. print("非空集合:", filled_set)
  8. filled_set.add(6)
  9. print("集合添加元素:", filled_set)
  11. filled_set.remove(6)
  12. print("集合删除元素:", filled_set)
  14. other_set = {3, 4, 5, 6, 7}
  16. a = filled_set & other_set
  17. print("集合 交集:", a)
  19. b = filled_set | other_set
  20. print("集合 并集:", b)
  22. c = filled_set - other_set
  23. print("集合 差集:", c)
  1. 空集合: set()
  2. 非空集合: {1, 2, 3, 4, 5}
  3. 集合添加元素: {1, 2, 3, 4, 5, 6}
  4. 集合删除元素: {1, 2, 3, 4, 5}
  5. 集合 交集: {3, 4, 5}
  6. 集合 并集: {1, 2, 3, 4, 5, 6, 7}
  7. 集合 差集: {1, 2}

4.流程控制

  1. # 分支判断
  3. # 单分支判断
  4. name = "QQ"
  5. if name != "":
  6.     print("hello %s!" % name)
  8. # 双分支判断
  9. is_true = True
  10. if is_true:
  11.     print("good!")
  12. else:
  13.     print("bad!")
  15. # 多分支判断
  16. score = 66
  17. if score >= 80:
  18.     print("优秀")
  19. elif score >= 60:
  20.     print("及格")
  21. else:
  22.     print("不及格")
  1. hello QQ!
  2. good!
  3. 及格
  1. # 循环
  3. # for循环
  4. sum = 0
  5. for i in range(1, 11):
  6.     print("for count: %d" % i)
  7.     sum += i
  8. print("1-10的数字之和: %d" % sum)
  10. # while循环
  11. sum = 0
  12. i = 10
  13. while i > 0:
  14.     sum += i
  15.     print("while count: %d" % i)
  16.     i -= 1
  17. print("10-1的数字之和: %d" % sum)
  1. for count: 1
  2. for count: 2
  3. for count: 3
  4. for count: 4
  5. for count: 5
  6. for count: 6
  7. for count: 7
  8. for count: 8
  9. for count: 9
  10. for count: 10
  11. 1-10的数字之和: 55
  12. while count: 10
  13. while count: 9
  14. while count: 8
  15. while count: 7
  16. while count: 6
  17. while count: 5
  18. while count: 4
  19. while count: 3
  20. while count: 2
  21. while count: 1
  22. 10-1的数字之和: 55

5. 函数

  1. # 将常用的代码块整理为函数，可以让代码更加整洁，可重复利用
  3. # 加法函数
  4. def sum(a, b):
  5.     return a + b
  7. sum_int = sum(1, 3)
  8. print("sum_int:", sum_int)
  10. sum_str = sum("hello ", "world!")
  11. print("sum_str:", sum_str)
  13. sum_list = sum([1,2], [3, 4])
  14. print("sum_list:", sum_list)
  17. # 任意连续整数之和
  18. def sum_start_to_end(start, end):
  19.     if not isinstance(start, int) or not isinstance(end, int):
  20.         print("错误的起止参数类型: start: %s, end: %s" % (type(start), type(end)))
  21.         return None
  22.     if start > end:
  23.         print("错误的起止参数: start: %s, end: %s" % (start, end))
  24.         return None
  25.     sum = 0
  26.     for i in range(start, end+1):
  27.         sum += i
  28.     return sum
  30. start = 1
  31. end = 100
  32. c = sum_start_to_end(start, end)
  33. print("sum %d to %d sum: %d:" % (start, end, c))
  1. sum_int: 4
  2. sum_str: hello world!
  3. sum_list: [1, 2, 3, 4]
  4. sum 1 to 100 sum: 5050:

6. 类

  1. # 类是代码对现实世界的抽象和模拟，同时可以对代码进行封装和管理
  3. class Animal(object):
  4.     name = None
  6.     def __init__(self, name):
  7.         self.name = name
  9.     def breathe(self):
  10.         print("%s breathe" % self.name)
  12.     @staticmethod
  13.     def grunt():
  14.         print("*grunt*")
  16. class Human(Animal):
  17.     def __init__(self, name):
  18.         super(Human, self).__init__(name)
  19.         #self.name = name
  21.     def say(self, msg):
  22.         print("{name} say: {message}".format(name=self.name, message=msg))
  25. a = Human("Jack")
  26. a.grunt()
  27. a.breathe()
  28. a.say("hello")
  1. *grunt*
  2. Jack breathe
  3. Jack say: hello

7.模块

  1. # 模块是文件级别的代码组织和管理方式，可以把常用的代码封装成一个模块便于代码复用，通常一个模块可以包含很多函数或者类
  3. # 官方提供的数学计算模块
  5. import math # 直接引入模块使用
  7. a = 16
  8. b = math.sqrt(a)
  9. print("%s 的开方结果：%s" % (a, b))
  11. from math import ceil, floor # 引入模块中的部分函数使用
  12. c = 3.7
  13. d = ceil(c)
  14. e = floor(c)
  15. print("%s 向上取证的结果: %s" % (c, d))
  16. print("%s 向下取证的结果: %s" % (c, e))
  19. import math as m # 引入模块并重命名使用
  20. print("math 模块的常量圆周率: %s" % m.pi)
  23. # 自定义模块
  25. # 示例1 单文件模块
  27. """
  28. #tree
  29. .
  30. ├── main.py
  31. ├── service.py
  33. # cat service.py
  34. #!/usr/bin/python
  35. # -*- coding: UTF-8 -*-
  37. def coffee_service():
  38.     print("you call coffee service!")
  40. # cat main.py
  41. #!/usr/bin/python
  42. # -*- coding: UTF-8 -*-
  44. import service
  46. if __name__ == "__main__":
  47.     service.coffee_service()
  48. """
  50. pass
  52. # 多文件模块示例
  54. """
  55. #tree
  56. .
  57. ├── main.py
  58. └── robot
  59.     ├── __init__.py
  60.     ├── robot1.py
  61.     └── robot2.py
  64. #cat robot/robot1.py
  65. #!/usr/bin/python
  66. # -*- coding: UTF-8 -*-
  68. def robot1_action():
  69.    print("I'm in robot1!")
  71. #cat robot/robot2.py
  72. #!/usr/bin/python
  73. # -*- coding: UTF-8 -*-
  75. def robot2_action():
  76.    print("I'm in robot2!")
  78. #cat robot/__init__.py
  79. #!/usr/bin/python
  80. # -*- coding: UTF-8 -*-
  82. if __name__ == '__main__':
  83.     print '作为主程序运行'
  84. else:
  85.     print 'robot模块初始化'
  87. #cat main.py
  88. #!/usr/bin/python
  89. # -*- coding: UTF-8 -*-
  91. # 导入robot包
  92. from robot.robot1 import robot1_action
  93. from robot.robot2 import robot2_action
  95. robot1_action()
  96. robot2_action()
  98. """
  100. pass
  1. 16 的开方结果：4.0
  2. 3.7 向上取证的结果: 4
  3. 3.7 向下取证的结果: 3
  4. math 模块的常量圆周率: 3.141592653589793