注释
注释介绍
- 在我们工作编码中，如果有一段代码的逻辑比较复杂不是特别容易理解，可以适当的添加注释，来辅助自己或其他编译人员解读代码。
- 注意：注释是给程序员看的，为了让程序员方便阅读代码，解释器会忽略注释。使用自己熟悉的语言，适当的对代码进行注释说明是一个良好的编码习惯。
注释分类
在Python中支持单行注释和多行注释
单行注释
- 以 # 开头，，#右边的所有内容当做说明，而不是真正要执行的程序，起辅助说明作用。
- 使用快捷键Ctrl+？单行注释
# #号开头的右边内容都是注释，解释器会忽略注释
print('hello world!') #作用是在控制台输出hello world！
#单行注释
# 打印一句话
#一般情况下 注释是在代码的上面书写的
print('繁花锦簇，硕果累累都需要过程') #有时也会将单行注释写在代码后面
# print('不能使用') 因为吧代码写在了注释后面多行注释
以 ''' 开始，以 ''' 结束，称之为多行注释
#多行注释
'''
你间歇性的努力和蒙混过日子
都是对之前努力的清零
print('哈哈哈哈哈')
'''变量以及数据类型
变量的定义
# Ctrl+？单行注释
# 没有变量的话，要重复的值书写起来很麻烦,因为如果修改的话要修改多个
print('今天天气晴朗')
print('今天天气晴朗')
print('今天天气晴朗')
print('今天天气晴朗')-
对于重复使用，并且经常需要修改的数据，可以定义为变量，来提高编程效率。
- 定义变量的语法：变量名 = 变量值 （这里面的 = 的作用是赋值）
- 定义变量后可以使用变量名来访问变量值
- 注意：输出时变量名不需要用引号包裹
-
# 在使用变量的情况下 # 变量格式：变量名字 = 变量的值 a = '今天天气阴天' print(a) #注意：变量名不需要用引号包裹 print(a) print(a) print(a) -
说明：
- 变量即是可以变化的量，可以随时进行修改。
- 程序就是用来处理数据的，而变量就是用来存储数据的。
变量的类型
程序中：在python里为了应对不同的业务需求，也把数据分为不同的类型
Numbers（数字）
- int（有符号整型） 如 1 ， 只有一种整数类型int，表示为长整型，没有python2中的Long.
- float（浮点型） 如1.23、3E-2
- complex（复数）如1+2j、1.1+2.2j
- long（长整型 也可以代表八进制和十六进制）：python 2中的类型，python 3 中没有了
# 变量的基本使用
# Number 数值
# int
money = 3000
# float
money1 = 3.2布尔类型
-
布尔类型只有两个值：True 和 False。
-
# boolean 布尔 # 应用 ①流程控制语句 ②性别的变量 # 性别在实际的企业开发中，使用的单词是sex gender # 男 True 女 False sex = True gender = False
String（字符串）
- Python 中单引号 ' 和双引号 " 使用完全相同。
- 只能双引号嵌套单引号或单引号嵌套双引号。
- 不可以单引号嵌套单引号或双引号嵌套上双引号。
-
#String 字符串 # 字符串 使用的是单引号或者双引号 a = '凤凰传奇' a1 = "自在摇曳 生生不息" # 不允许一单一双 # a2 = '哈哈" # 可以单引号和双引号嵌套 a3 = '"少说永远 过好此刻"' a4 = "'哇哦'" print(a3) print(a4) # 不可以 单引号嵌套单引号，双引号嵌套双引号 # a5 = ''单引号嵌套单引号'' # a6 = ""双引号嵌套双引号""
- 使用三引号(''' 或 """)可以指定一个多行字符串。
-
word = '字符串' sentence = "这是一个句子。" paragraph = """这是一个段落， 可以由多行组成"""
-
- 转义符 \。
- 反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。 如 r"this is a line with \n" 则 \n 会显示，并不是换行。
- 按字面意义级联字符串，如 "this " "is " "string" 会被自动转换为 this is string。
- 字符串可以用 + 运算符连接在一起，用 * 运算符重复。
- Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
- Python 中的字符串不能改变。
- Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
- 字符串切片 str[start:end]，其中 start（包含）是切片开始的索引，end（不包含）是切片结束的索引。索引值以 0 为开始值，-1 为从末尾的开始位置。
- 字符串的切片可以加上步长参数 step，语法格式如下：str[start:end:step]
str='123456789'
print(str) # 输出字符串
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
print(str[0]) # 输出字符串第一个字符
print(str[2:5]) # 输出从第三个开始到第六个的字符（不包含）
print(str[2:]) # 输出从第三个开始后的所有字符
print(str[1:5:2]) # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
print(str * 2) # 输出字符串两次
print(str + '你好') # 连接字符串
print('------------------------------')
print('hello\nrunoob') # 使用反斜杠(\)+n转义特殊字符
# r 指 raw，即 raw string，会自动将反斜杠转义
print(r'hello\nrunoob') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义List（列表）
- 列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
- 和字符串一样，列表可以被索引和切片。
- 列表可以使用 + 运算符连接在一起，用 * 运算符重复。
- 列表中的元素是可以改变的。
-
# list 列表 # 应用：当获取到很多数据时，我们可以将他们存储到列表中，然后直接使用列表的访问 name_list = ['abcd',123,'apple'] print(name_list) list1 = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ] # 定义一个列表 list2 = [123, 'runoob'] print (list1) # 打印整个列表 print (list1[0]) # 打印列表的第一个元素 print (list1[1:3]) # 打印列表第二到第三个元素（不包含第三个元素） print (list1[2:]) # 打印列表从第三个元素开始到末尾 print (list2 * 2) # 打印tinylist列表两次 print (list1 + list2) # 打印两个列表拼接在一起的结果 #输出 ['abcd', 123, 'apple'] ['abcd', 786, 2.23, 'runoob', 70.2] abcd [786, 2.23] [2.23, 'runoob', 70.2] [123, 'runoob', 123, 'runoob'] ['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']
Tuple（元组）
- 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
- 元组中的元素类型可以不相同
- 元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取
- 元组也可以使用 + 操作符进行拼接，*操作符进行重复
-
# tuple 元组 age_tuple = (18,19,20,21) print(age_tuple) tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 ) tuple1 = (123, 'runoob') print (tuple) # 输出完整元组 print (tuple[0]) # 输出元组的第一个元素 print (tuple[1:3]) # 输出从第二个元素开始到第三个元素 print (tuple[2:]) # 输出从第三个元素开始的所有元素 print (tuple1 * 2) # 输出两次元组 print (tuple + tuple1) # 连接元组 #输出 (18, 19, 20, 21) ('abcd', 786, 2.23, 'runoob', 70.2) abcd (786, 2.23) (2.23, 'runoob', 70.2) (123, 'runoob', 123, 'runoob') ('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')
Dictionary（字典）
- 字典（dictionary）是Python中另一个非常有用的内置数据类型。
- 字典的语法格式：{key:value,key1:value1,key2,value2}
- 列表是有序的对象集合，字典是无序的对象集合。
- 列表与字典的区别：字典当中的元素是通过键来存取的，而不是通过偏移存取。
- 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。键(key)必须使用不可变类型，在同一个字典中，键(key)必须是唯一的。
- 字典的关键字必须为不可变类型，且不能重复
- 创建空字典使用 { }。
查看数据类型
- 在python中只要是定义了一个变量，而且它有数据，那么他的类型就已经确定了，不需要咱们开发者主动的去说明他的类型，系统会自动辨别。即使用时“变量没有类型，数据才有类型”
- 如果临时想要查看一个变量存储的数据类型，可以使用type(变量的名字)，来查看变量存储的数据类型。
-
# int a = 1 print(a) print(type(a)) # float b = 1.2 print(b) print(type(b)) # boolean c = True print(c) print(type(c)) # string d = '中国' print(d) print(type(d)) # list e = [1,2,3,4] print(e) print(type(e)) # tuple f = (1,2,3,4,5) print(f) print(type(f)) # dict g = {'name':'lily'} print(g) print(type(g)) #输出 1 <class 'int'> 1.2 <class 'float'> True <class 'bool'> 中国 <class 'str'> [1, 2, 3, 4] <class 'list'> (1, 2, 3, 4, 5) <class 'tuple'> {'name': 'lily'} <class 'dict'>
标识符和关键字
计算机编程语言中，标识符时用户编程时使用的名字，用于给变量、常量、函数、语句块等命名。以建立起名称与使用之间的关系。
- 标识符由字母、下划线和数字组成，且数字不能开头。
- 严格区分大小写
- 不能使用关键字
命名规范
- 标识符命名要起一个有意义的名字，尽量做到看到就知道什么意思
- 遵守一定的命名规范
- 驼峰命名法
- 大驼峰命名法：每一个单词的首字母都采用大写字母。例如FirstName
- 小驼峰命名法：第一个单词以小写字母开始，第二个单词的首字母大写，例如myName
- 用下划线“_”来连接所有的单词。例如send_buf
- Python的命名规则遵循PEP8标准
- 驼峰命名法
关键字
- 关键字的概念：一些具有特殊功能的标识符，就是所谓的关键字。（因为关键字已经被python官方使用，所以不允许开发者自己定义和关键字相同名字的标识符。）
- 关键字
false None True and as assert break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield
- 关键字
类型转换
| 函数 | 说明 |
|---|---|
| int(x) | 将x转换成一个整数 |
| float(x) | 将x转换成一个浮点数 |
| str(x) | 将对象x转换成字符串 |
| bool(x) | 将对象转换成布尔值 |
转换成整数
-
# 转换成整数 #将字符串转换成为整数 print(int('123')) #将浮点数转换成为整数;float转换为整数,返回的是小数点前的数据 print(int(123.23)) #布尔值True转换为整数是1 #强制类型转换为谁 就写什么方法 print(int(True)) #布尔值False转换为整数是0 print(int(False)) #输出 123 123 1 0 - 以下两种情况会转换失败（如果包含非法字符会报错）
# 1.23和12ab 字符串,都包含非法字符,不能转换成为整数,会报错 a = '1.23' print(type(a)) print(int(a)) b = '12ab' print(int(b))
转换成浮点数
# 转换为浮点数
a = '12.34'
print(type(a))
# 将字符串类型转换为浮点数
b = float(a)
print(b)
print(type(b))
a1 = 12
print(type(a1))
# 将整数转换为浮点数
b1 =float(a1)
print(b1)
print(type(b1))
# 输出
<class 'str'>
12.34
<class 'float'>
<class 'int'>
12.0
<class 'float'>转换成布尔型
整数类型转换为布尔类型
- 在整数范围内 0 强制类型转换为bool类型结果是False
a7 = 0 print(type(a7)) b7 = bool(a7) print(b7) print(type(b7)) # 输出 <class 'int'> False <class 'bool'> - 如果对非0 的整数（int 包含正数和负数）进行bool类型的转换那么就全都是True
a5 = 1 print(type(a5)) # 将整数变成布尔类型的数据 b5 = bool(a5) print(b5) print(type(b5)) a6 = -1 print(type(a6)) b6 = bool(a6) print(b6) print(type(b6)) # 输出 <class 'int'> True <class 'bool'> <class 'int'> True <class 'bool'>
浮点数转换为布尔类型
- 将浮点数转换为bool类型的数据的时侯，正的浮点数和负的浮点数结果时True
a1 = 1.0 print(type(a1)) b8 = bool(a1) print(b1) print(type(b1)) a2 = 1.0 print(type(a2)) b2 = bool(a2) print(b2) print(type(b2)) #输出 <class 'int'> True <class 'bool'> <class 'int'> True <class 'bool'> <class 'int'> False <class 'bool'>
字符串转换为布尔类型
- 只要字符串中有内容，那么在强制类型转换为bool的时候，就返回True
- 空格也算内容
- 字符串中是空的字符串，那么返回False
#字符串转换为bool a1 = '你好' print(type(a1)) b1 = bool(a1) print(b1) print(type(b1)) a2 = " " print(type(a2)) b2 = bool(a2) print(b2) print(type(b2)) a3 = "" print(type(a3)) b3 = bool(a3) print(b3) print(type(b3)) #输出 <class 'str'> True <class 'bool'> <class 'str'> True <class 'bool'> <class 'str'> False <class 'bool'>
列表转换为布尔类型
- 只要列表中有数据，那么强制转换为bool的时候，就返回True
- 如果列表中什么数据都没有的情况下，那么就返回的事False
#列表转换为bool a1 = [123,'abcd','lily'] print(type(a1)) b1 = bool(a1) print(b1) print(type(b1)) a2 = [] print(type(a2)) b2 = bool(a2) print(b2) print(type(b2)) #输出 <class 'list'> True <class 'bool'> <class 'list'> False <class 'bool'>
元组转换为布尔类型
- 只要元组中有数据，那么强制转换为bool的时候，就返回True
- 如果元组中什么数据都没有的情况下，那么就返回的事False
#元组转换为bool a1 = {"name":'lily'} print(type(a1)) b1 = bool(a1) print(b1) print(type(b1)) a2 = {} print(type(a2)) b2 = bool(a2) print(b2) print(type(b2)) #输出 <class 'dict'> True <class 'bool'> <class 'dict'> False <class 'bool'>
总结什么情况下是False
print(type(b2))
print(bool(0))
print(bool(0.0))
print(bool(''))
print(bool(""))
print(bool([]))
print(bool(()))
print(bool({}))运算符
算术运算符
下面以a = 10 , b = 20 为例
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 | 两个对象相加 a + b 输出结果为 30 |
| - | 减 | 得到一个负数或是一个数减去另一个数 a - b 输出结果为 -10 |
| * | 乘 | 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果200 |
| / | 除 | b / a 输出结果 2 |
| // | 取整除 | 返回商的整数部分 9/2 输出结果4，9.0//2.0输出结果4.0 |
| % | 取余 | 返回除法的余数 b% a 输出结果 0 |
| ** | 指数 | a**b 为10的20次方 |
| () | 小括号 | 提高运算优先级 |
注意：
- 混合运算时，优先级顺序为： ** 高于 * / % // 高于 + - ,为了避免歧义，建议使用 () 来处理运算符优先级。
- 不同类型的数字在进行混合运算时，整数将会转换成浮点数进行运算
-
a = 7 b = 2 print(a + b) print(a - b) print(a * b) print(a / b) # 取整 print(a // b) # 取余 print(a % b) # 指数 幂 print(a ** b) #小括号 print((a+b)*a) #输出 9 5 14 3.5 3 1 49 63 - 如果两个字符串做加法运算，会直接把两个字符串拼接成一个字符串。即在python中 + 两端都是字符串才可以进行加法运算
str1 = 'hello' str2 = 'world' print(str1+str2) #输出 helloworld - 如果是数字和字符串做加法运算，会直接报错。
str1 = 'hello' a = 2 print(str1+a) 输出 Traceback (most recent call last): File "............", line 22, in <module> print(str1+a) ~~~~^~ TypeError: can only concatenate str (not "int") to str - 如果是数字和字符串做乘法运算，会将这个字符串重复多次。
str1 = 'hello' str2 = 3 print(str1*str2) #输出 hellohellohello
赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 赋值运算符 | 把 = 号右边的结果 赋给 左边的变量，如num = 1 + 2 * 3 , 结果num的值为7 |
- 单个变量赋值
- 同时为多个变量赋值——使用等号连接
- 多个变量赋值——使用逗号分隔
-
# 单个变量赋值 num1 = 10 print(num1) # 同时给多个变量赋值（使用等号连接） a = b = 3 print(a) print(b) # 多个变量赋值（使用逗号分隔） m,n,s,f = 100,3.14,'你好','hello' print(m) print(n) print(s) print(f) #输出 10 3 3 100 3.14 你好 hello
复合赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| += | 加法赋值运算符 | 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 |
a = 1
b = 2
b += a # b = b + a
print(a)
a1 = 3
a1 *= b # a1 = a1 * b
print(a1)
a2 = 4
a2 /= 2 # a2 = a2 / 2
print(a2)
a3 = 3
a3 //= 2 # a3 = a3 // 2
print(a3)
a4 = 7
a4 %= 4 # a4 = a4 % 4
print(a4)
a5 = 5
a5 **= 3 # a5 = a5 **3
print(a5)比较运算符
下面假设变量 a = 10，变量 b = 20:
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于：比较对象是否相等 | (a == b) 返回 False |
| != | 不等于：比较两个对象是否不相等 | (a != b) 返回True |
| > | 大于：返回x是否大于y | (a > b) 返回 False |
| >= | 大于等于：返回 x 是否大于等于 y | (a >= b) 返回 False |
| < | 小于：返回 x 是否小于 y 。所以比较运算符返回 1 表示真，返回 0 表示假。分别与特殊的变量 True 和 False 等价 | (a < b) 返回True |
| <= | 小于等于：返回 x 是否小于等于 y | (a <= b) 返回True |
a = 10
b = 20
# 判断 == 两边的变量是否一致
print(a == b)
# 判断 != 两边的变量是否不一致
print(a != b)
# 大于
print(a > b)
# 大于等于
print(a >= b)
# 小于
print(a < b)
# 小于等于
print(a <= b)
#输出
False
True
False
False
True
True逻辑运算符
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 只要有一个运算数是Fasle，结果就是False; 只要所有的运算数都为True时，结果才是True； 做取值运算时，取第一个为False的值，如果所有的都为True，取最后一个值（x为true，则返回y的值；x为false，则不计算y，直接返回false） | True and True and False --->结果为False True and True and True ---->结果为True |
| or | x or y | 只要有一个运算数是True，结果就是True; 只要所有的运算数都为False时，结果才是False； 做取值运算时，取第一个为True的值，如果所有的都为False，取最后一个值（x为true，则不计算y，直接返回true；x为false，则返回y） | False or False or True ------->结果为 True False or False or False ----->结果为False |
| not | not x | 布尔 “非” ， 如果 x 为 True ，返回False ； 如果 x 为 False ，返回 True。 | not True ----> False |
是
s
逻辑运算符的性能优化
- and的性能优化：当and前面的结果是False的情况下，那么后面的代码就不执行了
-
or的性能优化：or 只要有一方为True 那么结果就是True
# 逻辑运算符性能优化 #and 的性能优化：当and 前面的结果是False的情况下，那么后面的代码就不再执行 a = 34 print('…………') a > 10 and print("hello world") print('…………') # and 短路 a < 10 and print("hello world") print('…………') #or的性能优化 ## or 只要有一方为True 那么结果就是True # or 短路 a > 10 or print("hello world") print('…………') a < 10 or print("hello world") #输出 ………… hello world ………… ………… ………… hello world
输入输出
输入
- 使用input()从控制台读取键盘输入的内容
-
name = input('请输入你的名字') print(name)
输出
- 普通输出
- 格式化输出
-
# 输出 # 普通输出 print('你好，欢迎') #格式化输出 age = 18 name = 'lily' print('年龄是' + str(18)) # %s 代表的是字符串 %d的是数值 print('我的名字是%s,年龄是%d' %(name,age))
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
