python格式

• 编译型语言-速度快：程序在执行之前需要一个专门的编译过程，把程序编译成为机器语言的文件，运行时不需要重新翻译，直接使用编译的结果就行了。程序执行效率高，依赖编译器。
  特点：统一编译执行；执行速度快，跨平台性差些。如 C、C++，
• 解释型语言-跨平台性好：解释型语言编写的程序不进行预先编译，以文本方式存储程序代码，会将代码一句一句直接运行。在发布程序时，看起来省了道编译工序，但是在运行程序的时候，必须先解释再运行。
  特点：一行一行翻译并执行；跨平台能力强，如python，

程序执行原理：内存条通常只有 4G / 8G / 16G / 32G

1. 程序 运行之前，程序是 保存在硬盘 中的
2. 当要运行一个程序时
   • 操作系统会首先让 CPU 把Python程序复制到 内存 中
   • Python 解释器 根据语法规则，从上向下 让 CPU 翻译 Python 程序中的代码
   • CPU 执行 内存 中的 程序代码即01代码

程序要执行，首先要被加载到内存

Python 2.x 与 3.x 版本简介：

提示：如果开发时，无法立即使用 Python 3.0（还有极少的第三方库不支持 3.0 的语法），建议

• 先使用 Python 3.0 版本进行开发
• 然后使用 Python 2.6、Python 2.7 来执行，并且做一些兼容性的处理

一、认识

1、执行 Python 程序的三种方式：

• 解释器 —— python / python3

• 交互式 —— ipython，
  1.直接在终端中运行解释器，而不输入要执行的文件名
  2.在 Python 的 Shell 中直接输入 Python 的代码，会立即看到程序执行结果
  3.退出 官方的解释器： exit()或者ctrl + d
  4.IPython：在命令行输入 ipython或 ipython3，

      print("hello")

• 集成开发环境 —— PyCharm
  执行(SHIFT + F10) / 调试(SHIFT + F9) ，单步执行按钮(F8)：
  具体方法：
  1. 先点击小虫子按钮，点击代码添加断点，有红色圆点标记
  2. 打开console选项，看到当前代码”蓝色高亮“
  3. 点击右侧的向下箭头，或者F8执行，

2、认识错误（BUG）

1. 手误单词错NameError: 注意，错误时代码单词的颜色，执行时出现nameError；
2. SyntaxError: invalid syntax，注意：执行时，向上箭头；
3. 缩进错误：注意，空格键，tab；每行代码顶格写，不要增加空格
4. python 2.x 默认不支持中文

单词列表

* error 错误
* name 名字
* defined 已经定义
* syntax 语法
* invalid 无效
* Indentation 索引
* unexpected 意外的，不期望的
* character 字符
* line 行
* encoding 编码
* declared 声明
* details 细节，详细信息
* ASCII 一种字符编码

3、（1）新建项目，

• 新建项目：通过 欢迎界面 或者菜单 File / New Project 可以
• 新建文件：在项目名称右键new python file，

命名规则：如 项目名，01_Python 基础、02分支、03循环

               文件名，hm_01_hello.py

注意：

1. 命名文件名时建议只使用 小写字母、数字 和 下划线
2. 文件名不能以数字开始

？？？实践：添加：指定项目位置，文件名称，python解释器版本

（2）多文件项目的演练

提示

• 在 PyCharm 中，要想让哪一个 Python 程序能够执行，必须首先通过 鼠标右键的方式执行 一下
• 对于初学者而言，在一个项目中设置多个程序可以执行，是非常方便的，可以方便对不同知识点的练习和测试；
  注意：在运行按钮左侧可以看到文件名称，执行的是选择的文件。
• ？？？对于商业项目而言，通常在一个项目中，只有一个 可以直接执行的 Python 源程序

4、注释

• 单行注释（行注释）：
  （1）以 # 开头，# 后面建议先添加一个空格；
  （2）# 在代码的后面，至少要有 两个空格；
  注意：如果全部注释都没有加空格，点击小灯泡-选择“reformat file”；
• 多行注释（块注释）：用 一对 连续的 三个 引号(单引号和双引号都可以)；

二、4个运算符，变量，动态输入

1、算数运算符

（2）逻辑运算：

与 and／或 or／非 not 三种。

运算符 逻辑表达式 描述
and x and y 只有 x 和 y 的值都为 True，才会返回 True
否则只要 x 或者 y 有一个值为 False，就返回 False
or x or y 只要 x 或者 y 有一个值为 True，就返回 True
只有 x 和 y 的值都为 False，才会返回 False
not not x 如果 x 为 True，返回 False
如果 x 为 False，返回 True

（3）比较（关系）运算符：

运算符 描述
== 检查两个操作数的值是否 相等，如果是，则条件成立，返回 True
!= 检查两个操作数的值是否 不相等，如果是，则条件成立，返回 True

（4）赋值运算符：

• 注意：赋值运算符中间不能使用空格

  运算符 描述 实例
  = 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
  += 加法赋值运算符 c += a 等效于 c = c + a
  -= 减法赋值运算符 c -= a 等效于 c = c - a
  = 乘法赋值运算符 c = a 等效于 c = c * a
  /= 除法赋值运算符 c /= a 等效于 c = c / a
  //= 取整除赋值运算符 c //= a 等效于 c = c // a
  %= 取 模 (余数)赋值运算符 c %= a 等效于 c = c % a
  **= 幂赋值运算符 c = a 等效于 c = c a

（1）算数运算符

运算符 描述 实例

• 加      10 + 20 = 30              

• 减      10 - 20 = -10             

• 乘      10 * 20 = 200             

  / 除 10 / 20 = 0.5
  // 取整除 返回除法的整数部分（商） 9 // 2 输出结果 4
  % 取余数 返回除法的余数 9 % 2 = 1
  ** 幂 又称次方、乘方，2 ** 3 = 8

• 在 Python 中 * 运算符还可以用于字符串，计算结果就是字符串重复指定次数的结果。

（2） 算数运算符的优先级：

• 先乘除后加减
• 同级运算符是 从左至右 计算
• 可以使用 () 调整计算的优先级

• 以下表格的算数优先级由高到最低顺序排列

  运算符 描述
  ** 幂 (最高优先级)
  • / % // 乘、除、取余数、取整除

  • •                   加法、减法      

      <= < > >= 比较运算符
      == != 等于运算符
      = %= /= //= -= += *= **= 赋值运算符
      not or and 逻辑运算符

2、变量

变量的命名：

• • 标示符可以由 字母、下划线 和 数字 组成，不能以数字开头，不能与关键字重名。区分大小写，

    注意：不能有#，-，感叹号！，（），&，点等

    变量名 需要由 二个 或 多个单词 ：每个单词都使用小写字母，使用 _下划线 连接。如first_name,

    小驼峰式命名法：firstName

    大驼峰式命名法：FirstName

当我们写：name="python"时，Python解释器干了两件事情：

• 1）在内存中创建了一个'python'的字符串；

• 2）在内存中创建了一个名为name的变量，并把它指向'python'。

  这时候把变量name赋值给另一个变量name1，这个操作实际上是把变量name1指向变量name所指向的数据，与变量name并无任何关系；若name值变化，name1的值依然无变化；name的值发生变化，相当于重新开辟了一块内存空间；而name1依然指向原有内存空间。

1. 变量定义：
   = ，变量名 = 值，= 的左右应该各保留一个空格。
2. 常量：
   常量就是不能变的变量，比如常用的数学常数π就是一个常量。
   在Python中，通常用全部大写的变量名表示常量：如 TOTAL；
3. 变量的类型：
   在 Python 中定义变量是 不需要指定类型。
   （1）数据类型可以分为 数字型 和 非数字型
   • 数字型
     • 整型 (int)
     • 浮点型（float）
     • 布尔型（bool）
       • 真 True 非 0 数 —— 非零即真，对应的数字是 1
       • 假 False 0，对应的数字是 0
     • 复数型 (complex)
       • 主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题
   • 非数字型
     • 字符串，str
     • 列表
     • 元组
     • 字典
       提示：在 Python 2.x 中，整数 根据保存数值的长度还分为：
     • int（整数）
     • long（长整数）
       在 Python 3.x只有：Int

     • 使用type 函数可以查看一个变量的类型，如type(name)。
       （2） 不同类型变量之间的计算：true是1，false是0，字符串用+连接，
       数字型变量 之间可以直接计算，

       字符串变量 之间使用 + 拼接字符串，

       字符串变量 和 整数 使用 * 重复拼接相同的字符串，

       数字型变量 和 字符串 之间 不能进行其他计算。
4. 输入和输出，动态提示输入：
   输入，就是 用代码 获取 用户通过 键盘 输入的信息。input字符串
   字符串变量 = input("提示信息：")
   （1）变量的输入及类型转换：price = float(input("请输入价格:"))
   （2）变量的格式化输出：print("命名%s" % (变量1, 变量2...))
   • 如果希望输出文字信息的同时，一起输出数据，就需要使用到格式化操作符。%格式化操作符
   • % 和不同的 字符 连用，不同类型的数据 需要使用 不同的格式化字符
     格式化字符 含义
     %s 字符串
     %d 有符号十进制整数，%06d 表示输出的整数显示位数，不足的地方使用 0 补全
     %f 浮点数，%.2f 表示小数点后只显示两位；%.3f，
     %% 输出 %
     实践：定义一个小数 scale，输出 数据比例是 10.00%？？？
     print("数据比例是 %.2f%%" % (scale * 100))

举例：格式化输出

name = input("what is your name:")
age = int(input("tell me you age:"))
job = input("job:")
salary = input("salary:")

info = '''
    ---- info of %s ------
    name:%s
    age:%d
    job:%s
    salary:%s'''%(name,name,age,job,salary)
print(info)

info2 = '''
    ---- info of {_name} ------
    name:{_name}
    age:{_age}
    job:{_job}
    salary:{_salary}
    '''.format(_name=name,_age=age,_job=job,_salary=salary)
print(info2)

info3 = '''
    ---- info of {0} ------
     name:{0}
     age:{1}
     job:{2}
     salary:{3}
     '''.format(name,age,job,salary)
print(info3)

三、流程控制：if，判断语句 又被称为 “分支语句”

注意：
1、Tab 和空格不要混用！代码的缩进为一个 `tab` 键，或者 **4** 个空格；
注意：tab键可以增加缩进，
2、if，else，elif语句以及缩进部分是一个 完整的代码块；
3、elif 和 else 都必须和 if 联合使用，而不能单独使用

4、缩进块后边顶格写的代码；
光标放在if代码块时，会有提示，点击该提示会直接跳到该行代码；
缩进方法：选中内容shift+tab或者tab
if/else下方注意缩进

语法格式如下：

if 要判断的条件:
    条件成立时，要做的事情
    ……
else:
    条件不成立时，要做的事情
    ……

if 条件1:
    条件1满足执行的代码
    ……
elif 条件2:
    条件2满足时，执行的代码
    ……
elif 条件3:
    条件3满足时，执行的代码
    ……
else:
    以上条件都不满足时，执行的代码
    ……

if 条件1 and 条件2:
    条件1满足 并且 条件2满足 执行的代码
    ……

if 条件 1:
    条件 1 满足执行的代码
    ……

    if 条件 1 基础上的条件 2:
        条件 2 满足时，执行的代码
        ……
    # 条件 2 不满足的处理
    else:
        条件 2 不满足时，执行的代码

# 条件 1 不满足的处理
else:
    条件1 不满足时，执行的代码
    ……

随机数的处理：

import random

random.randint(a, b) ，返回 [a, b] 之间的整数，包含 a 和 b

练习：

# 练习3: 定义一个布尔型变量 `is_employee`，编写代码判断是否是本公司员工
is_employee = True

# 如果不是提示不允许入内
if not is_employee:
    print("非公勿内")

if has_ticket:
    print("有车票，可以开始安检...")

四、while 循环

注意：
1、while 语句以及缩进部分是一个 完整的代码块
2、循环结束后，之前定义的计数器条件的数值是依旧存在的
3、死循环：
由于程序员的原因，忘记 在循环内部 修改循环的判断条件，导致循环持续执行，程序无法终止！
4、大家在编写程序时，应该尽量养成习惯：除非需求的特殊要求，否则 循环 的计数都从 0 开始

while 语句基本语法

初始条件设置 —— 通常是重复执行的 计数器
result = 0
i = 0

# while 条件(判断 计数器 是否达到 目标次数):
while i <= 5:
    # 判断偶数
    if i % 2 == 0:

    条件满足时，做的事情1
     print(i)
    条件满足时，做的事情2
    ...(省略)...

     result += i

    处理条件(计数器 + 1)
     i += 1

print("循环结束后的 = %d" % result)        

循环嵌套

while 条件 1:
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
    ...(省略)...

    while 条件 2:
        条件满足时，做的事情1
        条件满足时，做的事情2
        条件满足时，做的事情3
        ...(省略)...

        处理条件 2

    处理条件 1

注意：
# 向控制台输出内容结束之后，不会换行
print("*", end="")

# 单纯的换行
print("")  

实践：九九乘法表

1> row 外循环-即每一行：完成 5 行内容的简单输出。
2> col 内循环-即每行的每一列：分析每行内部的 * 应该如何处理？
  - 每行显示的星星和当前所在的行数是一致的
  - 嵌套一个小的循环，专门处理每一行中 列 的星星显示

# 定义起始行
row = 1

while row <= 9:
    # 在循环内部，再增加一个循环，实现每一行的 星星 打印
     # 定义起始列
    col = 1

    while col <= row:
        # "\t" 可以在控制台输出一个制表符，协助在输出文本时对齐
        print("%d * %d = %d" % (col, row, row * col), end="\t")

        # 列数 + 1
        col += 1

    # 每一行输出完成后，再增加一个换行
    print("")

    # 行数 + 1
    row += 1

break 和 continue

#举例： 1、break退出整个循环
while True:
    print（1）
    break
    print（2）
上面的代码会先输出1，然后遇到break，就退出当前循环，所以不再打印出2了。

# 2、continue退出当前循环
while True:
    print（1）
    continue
    print（2）
不停的输出1，永远不会输出2。　

• break 某一条件满足时，退出循环，不再执行后续重复的代码；

• continue 某一条件满足时，不执行后续重复的代码；

  break：即就是直接跳出循环。一旦发现 条件满足，整个循环结束，
  continue：即就是跳到循环体条件上。只是排除某一个特定条件，
  
  注意：
  1、break 和 continue 只针对 当前所在循环 有效。
  2、使用 continue 时，条件处理部分的代码，需要特别注意，不小心会出现 死循环

字符串中的转义字符

• \t 在控制台输出一个 制表符，协助在输出文本时 垂直方向 保持对齐
• \n 在控制台输出一个 换行符

制表符 的功能是在不使用表格的情况下在 垂直方向 按列对齐文本

转义字符 描述
\ 反斜杠符号
' 单引号
" 双引号
\n 换行
\t 横向制表符
\r 回车

五、函数

• 函数的快速体验
• 函数的基本使用
• 函数的参数
• 函数的返回值
• 函数的嵌套调用
• 在模块中定义函数

1、快速体验

• 所谓函数，就是把 具有独立功能的代码块 组织为一个小模块，在需要的时候 调用
• 函数的使用包含两个步骤：
  1. 定义函数 —— 封装 独立的功能
  2. 调用函数 —— 享受 封装 的成果

  # def multiple_table():另一个表中定义的函数

  import hm_乘法表
  hm_乘法表.multiple_table()

2、函数基本使用

# def 函数名():
def sum_2_num(num1, num2):
    """对两个数字的求和"""

    #函数封装的代码
    result = num1 + num2
    print("%d + %d = %d" % (num1, num2, result))

sum_2_num(50, 20)

 函数的注释：应该在 定义函数 的下方，使用 连续的三对引号
1、在 连续的三对引号 之间编写对函数的说明文字
2、在 函数调用 位置，使用快捷键 CTRL + Q 可以查看函数的说明信息
注意：因为 函数体相对比较独立，函数定义的上方，应该和其他代码（包括注释）保留 两个空行。

函数名称 的命名应该 符合 标识符的命名规则

• 可以由 字母、下划线 和 数字 组成
• 不能以数字开头

• 不能与关键字重名

  举例：
  name = "小明"

  # 解释器知道这里定义了一个函数
  def say_hello():
  print("hello 1")
  print("hello 2")
  print("hello 3")

  print(name)
  # 只有在调用函数时，之前定义的函数才会被执行
  # 函数执行完成之后，会重新回到之前的程序中，继续执行后续的代码
  say_hello()

  print(name)

用 单步执行 F8 和 F7 观察以下代码的执行过程；

• F8 Step Over 可以单步执行代码，会把函数调用看作是一行代码直接执行

• F7 Step Into 可以单步执行代码，如果是函数，会进入函数内部

  1、定义好函数之后，只表示这个函数封装了一段代码而已
  2、如果不主动调用函数，函数是不会主动执行的
  3、不能将 函数调用 放在 函数定义 的上方。
  因为在 使用函数名 调用函数之前，必须要保证 Python 已经知道函数的存在，否则控制台会提示 NameError: name 'say_hello' is not defined (名称错误：say_hello 这个名字没有被定义)

3、函数的参数

（1）在函数名的后面的小括号内部填写 参数，多个参数之间使用 , 分隔：如 def sum_2_num(num1, num2):

（2）形参和实参：

• 形参：定义 函数时，小括号中的参数，是用来接收参数用的，在函数内部 作为变量使用
• 实参：调用 函数时，小括号中的参数，是用来把数据传递到 函数内部 用的

4、函数的返回值：

• 返回值 是函数 完成工作后，最后 给调用者的 一个结果
• 在函数中使用 return 关键字可以返回结果
• 调用函数一方，可以 使用变量 来 接收 函数的返回结果

注意：return 表示返回，后续的代码都不会被执行

# def 函数名():
def sum_2_num(num1, num2):
    """对两个数字的求和"""

    #函数封装的代码
    return num1 + num2

# 调用函数，并使用 result 变量接收计算结果
result = sum_2_num(10, 20)
print("计算结果是 %d" % result)

5、函数的嵌套调用

• 一个函数里面 又调用 了 另外一个函数，这就是 函数嵌套调用
• 如果函数 test2 中，调用了另外一个函数 test1
  • 那么执行到调用 test1 函数时，会先把函数 test1 中的任务都执行完
  • 才会回到 test2 中调用函数 test1 的位置，继续执行后续的代码

6、使用模块中的函数

模块是 Python 程序架构的一个核心概念

• 模块 就好比是 工具包，要想使用这个工具包中的工具，就需要 导入 import 这个模块
• 每一个以扩展名 py 结尾的 Python 源代码文件都是一个 模块
• 在模块中定义的 全局变量 、 函数 都是模块能够提供给外界直接使用的工具；
• 模块名也是一个标识符：
  • 标示符可以由 字母、下划线 和 数字 组成
  • 不能以数字开头

  • 不能与关键字重名
    注意：如果在给 Python 文件起名时，以数字开头 是无法在 PyCharm 中通过导入这个模块的

    体验小结：
    1、可以 在一个 Python 文件 中 定义 变量 或者 函数；如name = "黑马程序员"
    2、然后在 另外一个文件中 使用 import 导入这个模块；
    3、导入之后，就可以使用 模块名.变量 / 模块名.函数 的方式，使用这个模块中定义的变量或者函数；如 hm_10_分隔线模块.print_line("-", 80)
    print(hm_10_分隔线模块.name)

    注意：模块可以让 曾经编写过的代码 方便的被 复用！

六、高级变量类型

• 列表
• 元组
• 字典
• 字符串
• 公共方法
• 变量高级