Python基础-3 语法知识点1

1.注释和运算符

目标

• 注释的作用
• 单行注释（行注释）
• 多行注释（块注释）

01.注释的作用
对代码进行标注说明，增强可读性

02.单行注释（行注释）

• 以#开头，#右边所有东西都被当成说明文字，而不是真正要执行的程序，只起到辅助说明作用
• 为了保证代码可读性，#后面建议先添加一个空格，然后再编写相应的说明文字

# 这是第一个单行注释
print('hello python!')

在代码后面增加的单行注释

• 开发程序同样可以使用#在代码后面增加说明性文字
• 为了保证代码可读性，注释和代码之间 至少要有 两个空格

print('hello python!')  # 输出'hello python'

03.多行注释（块注释）

• 如果希望 注释信息很多，一行无法显示，可以使用多行注释
• 注释用一对 连续的 三个 引号（单引号和双引号都可以）

'''
这是一个多行注释
'''
"""
这也是一个多行注释
"""
print('hello python!')

目标

• 算术运算法的基本使用

01.算术运算符

运算符	描述
+	加，10+20=30
-	减，10-20=-10
*	乘， 10*20=200
/	除，10/20=0.5
/ /	取整除，返回除法的整数部分 9//2=4
%	取余数，返回除法的余数 9%2=1
**	幂， 2**3=8

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

print('-' * 50)  # 输出结果：--------------------------------------------------

02.算术运算符的优先级

• 和数学运算符优先级一致，先乘除后加减，同级运算符是 从左至右计算
• 以下表格的优先级由高到低排列

运算符	描述
**	幂
* / % //	乘、除、取余数、取整数
+ -	加、减

2.变量的类型及命名

变量的类型

• 在Python中定义的变量是 不需要指定类型的
• 数据类型包括6种：数（int整型、float浮点型、bool布尔型-True为非0数 False为0、complex复数）、字符串（String）、列表（list）、元组（tuple）、集合（set）、字典（dictionary）

type(变量) # 查看变量的数据类型

变量的格式化输出

• 在Python中可以用print函数将信息输出到控制台
• 如果希望输出文字同时，一起输出 数据，就需要使用到 格式化操作符
• %被称为 格式化操作符，专门处理字符串中的格式
  包含%的字符串，被称为 格式化字符串，不同类型的数据 需要使用 不同的格式化字符

格式化字符	含义
%s	字符串
%d	有符号十进制整数，%06d表示输出的整数显示位数，不足的地方使用0补全，超过6位的话都显示
%f	浮点数，%.02f表示小数点后只显示两位
%%	输出%

print('格式化字符串' % 变量1 )
print('格式化字符串' % （变量1,变量2...） )

name = '小明'
stu_no = 3119901234
height = 1.78
weight = 68.05
print('我的名字是 %s' % name)
print('我的学号是 %06d' % stu_no)
print('我的身高是 %.02f，体重是 %.02f' % (height, weight))

变量的命名
01.标识符和关键字
标识符：就是程序员定义的 变量名、函数名

• 标识符可以由 字母、下划线 和 数字 组成
• 不能以 数字 开头
• 不能与 关键字 重名

以下划线开头的标识符是有特殊意义的。

• 以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入。
• 以双下划线开头的 __foo 代表类的私有成员，以双下划线开头和结尾的 foo 代表 Python 里特殊方法专用的标识，如 init() 代表类的构造函数。
• Python 可以同一行显示多条语句，方法是用分号 ; 分开

关键字：就是在Python内部已经使用的标识符
通过以下命令查看Python中的关键字：

import keyword
print(keyword.kwlist)

02.变量的命名规则
Python中的 标识符 是 区分大小写的

Name ≠ name

• 定义变量时，= 的左右应该各保留一个空格
• 如果 变量名 需要由多个单词组成时，按以下方式命名
  1.每个单词都是小写
  2.单词之间使用 _下划线 连接

驼峰命名发法
当 变量名 是由多个单词组成时，也可以用驼峰命名法

小驼峰式命名法：第一个单词以小写字母开始，后续单词的首字母大写，例如：firstName

大驼峰式命名法：每一个单词的首字母都采用大写字母，例如：FirstName

3.判断和循环语句

if判断语句
格式如下：

if 条件1：
	成立时的逻辑
elif 条件2：
	成立时的逻辑
else:
	不成立时的逻辑

注意：
1.代码的索引为一个tab键，或者4个空格，if、elif和else语句以及缩进部分是一个 完整的代码块
2.elif 和 else 都必须和 if联合使用

运算符
01.比较运算

运算符	描述
==	两边值相等，返回true
!=	两边值不相等，返回true
>	左边大于右边，返回true
<	左边小于右边，返回true
>=	左边大于等于右边，返回true
<=	左边小于等于右边，返回true

02逻辑运算
Python中的 逻辑运算符 包括：与and/或or/非not 三种

随机数的处理

导入随机数的模块

import random

导入模块后，在模块名称后面敲一个.，然后按Tab，会提示模块中包含的所有函数

random.randint(a,b) # 返回[a,b]之间的数字，包括a,b，运行条件：b>=a

while循环
格式如下：

初始条件设置：定义重复次数计数器

while 条件(判断计数器是否达到目标次数)：
	满足条件执行逻辑
	...
	处理条件(计数器+1)

break 和 continue

• break 某一条件满足时，退出当前循环，不在执行后续重复代码
• continue 某一条件满足时，不执行本次循环的后续代码，进入下一次循环

注意：break和continue都是作用于本层循环

for i in range(0,3):
    if i==1:
        continue
        print('---'+str(i))
    print(i)
print('循环外代码1')

print("-=-=-=-=-=-=-=-=-=")

for i in range(0,3):
    if i == 1:
        break
        print('===' + str(i))
    print(i)
print('循环外代码2')

print("-=-=-=-=-=-=-=-=-=")

for i in range(0,3):
    print('外层===' + str(i))
    for j in range(0,3):
        if j==1:
            break
            print('===' + str(j))
        print('内层==='+str(j))
print('循环外代码3')

结果：
0
2
循环外代码1
-=-=-=-=-=-=-=-=-=
0
循环外代码2
-=-=-=-=-=-=-=-=-=
外层===0
内层===0
外层===1
内层===0
外层===2
内层===0
循环外代码3

赋值运算符

运算符	实例
=	c = a+b
+=	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

注意：赋值运算符中间不能有空格

4.函数的说明

01.函数的定义

简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

# 定义函数
def say_hello():
    '''函数说明信息'''
    print('hello')
#调用函数
say_hello()

def sum_2_num(num1,num2):
    result = num1 + num2
    print("%d + %d = %d" % (num1,num2,result))
    return result
result = sum_2_num(10,20)
print("计算结果： %d" % result)

02.函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

03.参数传递

在 python 中，类型属于对象，变量是没有类型的：

a=[1,2,3]
 
a="Runoob"

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5被丢弃，不是改变a的值，相当于新生成了a。
• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
  python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

python 传不可变对象实例

def ChangeInt(a):
    a = 10
b = 2
ChangeInt(b)
print (b)  # 结果是 2

实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。

传可变对象实例

# 可写函数说明
def changeme(mylist):
    "修改传入的列表"
    mylist.append([1, 2, 3, 4])
    print("函数内取值: ", mylist)
    return

# 调用changeme函数
mylist = [10, 20, 30]
changeme(mylist)
print("函数外取值: ", mylist)

结果：
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

dir()函数

dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字。
返回的列表容纳了在一个模块里定义的所有模块，变量和函数。如下一个简单的实例：

# 导入内置math模块
import math
content = dir(math)
print(content)
结果：
['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 
'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 
'sqrt', 'tan', 'tanh']

• F8 Step Over 可以单步执行代码，会把函数调用看作是一行代码直接放行
• F7 Step Into 可以单步执行代码，如果是函数，会进入函数内部

4.模块的说明

Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
模块能定义函数，类和变量，模块里也能包含可执行的代码。

import 语句
模块的引入
模块定义好后，我们可以使用 import 语句来引入模块，语法如下：

import module1,module2
eg:
import math

在调用 math 模块中的函数时，必须这样引用：

模块名.函数名

from…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：

from modname import name1, name2

搜索路径

当你导入一个模块，Python 解析器对模块位置的搜索顺序是：

1. 当前目录
2. 如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
3. 如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。

模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。

PYTHONPATH 变量

作为环境变量，PYTHONPATH 由装在一个列表里的许多目录组成。PYTHONPATH 的语法和 shell 变量 PATH 的一样。
在 Windows 系统，典型的 PYTHONPATH 如下：

set PYTHONPATH=c:\python27\lib;

在 UNIX 系统，典型的 PYTHONPATH 如下：

set PYTHONPATH=/usr/local/lib/python

命名空间和作用域

变量是拥有匹配对象的名字（标识符）。命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。
一个 Python 表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。
每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。
Python 会智能地猜测一个变量是局部的还是全局的，它假设任何在函数内赋值的变量都是局部的。
因此，如果要给函数内的全局变量赋值，必须使用 global 语句。
global VarName 的表达式会告诉 Python， VarName 是一个全局变量，这样 Python 就不会在局部命名空间里寻找这个变量了。
例如，我们在全局命名空间里定义一个变量 Money。我们再在函数内给变量 Money 赋值，然后 Python 会假定 Money 是一个局部变量。然而，我们并没有在访问前声明一个局部变量 Money，结果就是会出现一个 UnboundLocalError 的错误。取消 global 语句前的注释符就能解决这个问题。

Money = 2000

def AddMoney():
    global Money
    Money = Money + 1

print(Money) # 2000
AddMoney()
print(Money) # 2001

globals() 和 locals() 函数

根据调用地方的不同，globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。
如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。
如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。
两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。

reload() 函数

当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。
因此，如果你想重新执行模块里顶层部分的代码，可以用 reload() 函数。该函数会重新导入之前导入过的模块。语法如下：

reload(module_name)

Python中的包

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。
简单来说，包就是文件夹，但该文件夹下必须存在 init.py 文件, 该文件的内容可以为空。init.py 用于标识当前文件夹是一个包。