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 解析器对模块位置的搜索顺序是:
- 当前目录
- 如果不在当前目录,Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
- 如果都找不到,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 用于标识当前文件夹是一个包。