标签：集合 打印 多个 index 优先级 减法 start class 空间
标识符是程序中自定义的一些符号和名称(如变量名、函数名、类名等)。为了能标识和引用对象，就需要给对象起一个名称，这个名称就叫做标识符。
命名规则：
标识符由字母，下划线和数字组成，且不能以数字开头
标识符长度可以是任意长度，不能包括空格，且区分大小写
标识符不能与关键字同名，可以在python交互下输入help(“keywords”)查看关键字，也可使用keyword模块中的iskeyword()方法来判断
import keyword
keyword.iskeyword(‘and‘)#输出True
keyword.iskeyword(‘And‘)#输出False
标识符应避免开头和结尾都使用下划线的情况
Python将所有数据存为内存对象，变量是用来标识对象和引用对象的，实际上就是指内存对象的引用。
变量名 = 值
firstName、lastNameFirstName、LastName、CamelCasepython中四种赋值方法：基本赋值、复合赋值、同步赋值、链式赋值
基本赋值
基本赋值就是：变量名 = [表达式、常量、变量]
注：如果赋值语号右侧是表达式，先计算表达式的值，再将该值存放再内存中某处。然后赋值给左边的变量指向该数据对象，构成引用关系。
python采用一种基于“值”的内存管理方式，如果给不同的变量赋值相同的值，这个值在内存中只存储一份，多个变量都指向同一块内存空间首地址，即多个变量都是同一个“值”的引用。这样可以减少内存空间的占用，提高内存利用率。
变量在内存中的存储地址可用用内置函数
id()来获得x = 10 print(x,id(x)) y=x print(y,id(y)) z=10 print(z,id(z))输出
10 140720589625280 10 140720589625280 10 140720589625280
复合赋值
复合赋值运算，详情见赋值运算符
注：所有的复合赋值运算符的优先级均相同，低于算术运算符和关系运算符，但高于逻辑运算符。所以x*=y+5等价与x=x*(y+5)
同步赋值
同步赋值是python语言中比较有特色的语句，使用它可以同时给多个变量赋以不同的值。
变量1，变量2，……，变量n = 表达式1，表达式2，……，表达式n注：赋值号的左侧的变量个数与赋值号右侧的表达式的个数要求严格一致
例1：
x,y,z = 10,["hello","world"],dict(name="LJB",age=18) print(x) print(y) print(z)输出：
10 [‘hello‘, ‘world‘] {‘name‘: ‘LJB‘, ‘age‘: 18}python语言中的同步赋值语句本质上就是元组的序列解包。在程序中使用同步赋值语句可以减少程序的语句条数，简化程序
例2：
x,y = 100,200 print(x,y) x,y = y,x print(x,y)输出：
100 200 200 100
链式赋值
当需要一次给多个变量赋以相同的值时，即多个变量都引用这同一个值，可以使用链式赋值语句
变量1=变量2=变量3=……=变量n=表达式例：
x=y=z={1,2,3} print(x) print(y) print(z) print(id(x),id(y),id(z))输出：
{1, 2, 3} {1, 2, 3} {1, 2, 3} 1751132512032 1751132512032 1751132512032
在 Python 中定义变量是 不需要指定类型（在其他很多高级语言中都需要）
数据类型可以分为 数字型 和 非数字型
数字型
整型 (int)
浮点型（float）
布尔型（bool）
复数型 (complex)
空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
非数字型
提示：在 Python 2.x 中，整数 根据保存数值的长度还分为：
int（整数）long（长整数）
type 函数可以查看一个变量的类型type(name)
bool 型，在计算时
True 对应的数字是 1False 对应的数字是 0+ 拼接字符串* 重复拼接相同的字符串In [1]: "-" * 50
Out[1]: ‘--------------------------------------------------‘
input 函数实现键盘输入
input 函数从键盘等待用户的输入语法如下：
字符串变量 = input("提示信息：")
类型转换函数
| 函数 | 说明 |
|---|---|
| int(x) | 将 x 转换为一个整数 |
| float(x) | 将 x 转换到一个浮点数 |
% 被称为 格式化操作符，专门用于处理字符串中的格式
% 的字符串，被称为 格式化字符串% 和不同的 字符 连用，不同类型的数据 需要使用 不同的格式化字符| 格式化字符 | 含义 |
|---|---|
| %s | 字符串 |
| %d | 有符号十进制整数，%06d 表示输出的整数显示位数，不足的地方使用 0 补全 |
| %f | 浮点数，%.2f 表示小数点后只显示两位 |
| %% | 输出 % |
print("格式化字符串" % 变量1)
print("格式化字符串" % (变量1, 变量2...))
python对象有五个数据类型：数字、列表、字符串、元组、字典
整型 (int)
浮点型（float）
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如
1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
布尔型（bool）
True 非 0 数 —— 非零即真False 0复数型 (complex)
对于很大的数，例如10000000000，很难数清楚0的个数。Python允许在数字中间以_分隔，因此，写成10_000_000_000和10000000000是完全一样的。十六进制数也可以写成0xa1b2_c3d4。
列表：列表中的数据可以是不相同的类型
list=[’d‘,1,3.1]字符串：把文本放入单引号
‘‘，双引号""或三引号‘‘‘‘‘‘中就可以表示字符串了如果字符串内部既包含
‘又包含"怎么办？可以用转义字符\来标识，元组：元组与列表相似，不同之处在于元组不能修改元素;元组写在()里面，元组中的元素可以不相同。
tuple=(‘dds‘,1,1.2)
序列类型的基本操作
| 操作 | 结果 |
|---|---|
| x in s | 序列s中是否包含x，返回布尔值 |
| x not in s | 序列s中是否不包含x，返回布尔值 |
| s[i] | 序列s的第i个元素，i初始值为0 |
| s[i:j] | 序列s的从下标i到下标j的切片，包含i，但不包含j |
字典是另一种可变容器，且可以存放任意类型的数据
字典的每个键值对(key=>value)用冒号:分割，每个对之间用逗号,分割整个字典在花括号{}中
d={key1:value1,key2:value2}
注意：键必须是唯一的，值则可不必。值可以取任何数据类型，但键必须是不可变的。
算数运算符是 运算符的一种
是完成基本的算术运算使用的符号，用来处理四则运算
| 运算符 | 描述 | 结果 |
|---|---|---|
| +、-*、/ | 加减乘除 | 略 |
| % | 取余 | 返回除法的余数 b % a 输出结果 0 |
| **[1] | 幂 | 返回x的y次幂 a**b 为 |
| //[2] | 整除 | 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
In [1]:9//4 Out[1]:2 In [2]:-9//4 Out[2]:-3 In [3]:9//-4 Out[3]:-3 In [4]:-9//-4 Out[4]:2In [1]:9%4 Out[1]:2 In [2]:-9%4 #-9-4*-3 Out[2]:3 In [3]:9%-4 #9--4*-3 Out[3]:-3 In [4]:-9%-4 #-9--4*2 Out[4]:-1
python的关系运算符可以连用
通常在书写表达式的生活，良好的风格是在每个运算符左右都放一个空格
| 运算符 | 描述 | 示例 |
|---|---|---|
| == | 检查两个操作数的值是否相等，如果是则条件变为真。 | 如a=3,b=3则（a == b) 为 true. |
| != | 检查两个操作数的值是否相等，如果值不相等，则条件变为真。 | 如a=1,b=3则(a != b) 为 true. |
| <> | 检查两个操作数的值是否相等，如果值不相等，则条件变为真。 | 如a=1,b=3则(a <> b) 为 true。这个类似于 != 运算符 |
| > | 检查左操作数的值是否大于右操作数的值，如果是，则条件成立。 | 如a=7,b=3则(a > b) 为 true. |
| < | 检查左操作数的值是否小于右操作数的值，如果是，则条件成立。 | 如a=7,b=3则(a < b) 为 false. |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。 | 如a=3,b=3则(a >= b) 为 true. |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。 | 如a=3,b=3则(a <= b) 为 true. |
| 运算符 | 描述 | 实例 |
|---|---|---|
| += | 加法赋值运算符 | 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 |
| 运算符 | 逻辑表达式 | 描述 |
|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 |
| or | x or y | 布尔"或" - 如果 x 是 True，它返回 True，否则它返回 y 的计算值。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 |
| ^ | a^b | 异或，当两个条件不相同时返回True |
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
身份运算符用于比较两个对象的存储单元
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
| is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 ‘AND‘ |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not and or | 逻辑运算符 |
在程序开发中，一共有三种流程方式：
顺序 —— 从上向下，顺序执行代码
分支 —— 根据条件判断，决定执行代码的 分支
循环 —— 让 特定代码 重复 执行
条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。这个过程就叫流程控制。
判断语句 又被称为 “分e支语句”，正是因为有了判断，才让程序有了很多的分支
在 Python 中，if 语句 就是用来进行判断的，格式如下：
if 条件:
条件成立时，要做的事情
else:
条件不成立时，要做的事情
注意：代码的缩进为一个 tab 键，或者 4 个空格 —— 建议使用空格
if 语句以及缩进部分是一个 完整的代码块另外if语句的双路分支结构还有一种更优雅的表达方式，适用于通过条件判断获得特定值的场合，其语法格式如下：
<表达式1> if <条件表达式> else <表达式2>
其中<条件表达式>的作用等同与双分支if-else语句格式中的表达式，
该语句的功能是先判断语句中<条件表达式>的值，如果<条件表达式>结果为真，则返回<表达式1>的值，如果<条件表达式>结果为假，则返回<表达式2>的值
a,b = 4,6
max = a if a>b else b
print(max) #输出6
在开发中，使用 if 可以 判断条件
使用 else 可以处理 条件不成立 的情况
但是，如果希望 再增加一些条件，条件不同，需要执行的代码也不同 时，就可以使用 elif
语法格式如下：
if 条件1:
条件1满足执行的代码
……
elif 条件2:
条件2满足时，执行的代码
……
elif 条件3:
条件3满足时，执行的代码
……
else:
以上条件都不满足时，执行的代码
……
注意
elif 和 else 都必须和 if 联合使用，而不能单独使用if、elif 和 else 以及各自缩进的代码，看成一个 **完整的代码在开发中，使用 if 进行条件判断，如果希望 在条件成立的执行语句中 再 增加条件判断，就可以使用 if 的嵌套
if 的嵌套 的应用场景就是：在之前条件满足的前提下，再增加额外的判断
if 的嵌套 的语法格式，除了缩进之外 和之前的没有区别
if 条件 1:
条件 1 满足执行的代码
if 条件 1 基础上的条件 2:
条件 2 满足时，执行的代码
# 条件 2 不满足的处理
else:
条件 2 不满足时，执行的代码
# 条件 1 不满足的处理
else:
条件1 不满足时，执行的代码
……
循环的作用就是让 指定的代码 重复的执行
while 循环最常用的应用场景就是 让执行的代码 按照 指定的次数 重复 执行
初始条件设置 —— 通常是重复执行的 计数器
while 条件(判断 计数器 是否达到 目标次数):
条件满足时，执行的代码
处理条件(计数器 + 1)
注意：while 语句以及缩进部分是一个 完整的代码块
常见的计数方法有两种，可以分别称为：
1 开始）—— 更符合人类的习惯0 开始）—— 几乎所有的程序语言都选择从 0 开始计数for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
for 临时变量 in 列表或者字符串等:
循环满足条件时执行的代码
else:
没有通过 break 退出循环，循环结束后，会执行的代码
例子示例：
# -*- coding: UTF-8 -*-
for letter in ‘Python‘: # 第一个实例
print ‘当前字母 :‘, letter
fruits = [‘banana‘, ‘apple‘, ‘mango‘]
for fruit in fruits: # 第二个实例
print ‘当前水果 :‘, fruit
for index in range(len(fruits)): #序列索引迭代
print ‘当前水果 :‘, fruits[index]
输出：
当前字母 : P
当前字母 : y
当前字母 : t
当前字母 : h
当前字母 : o
当前字母 : n
当前水果 : banana
当前水果 : apple
当前水果 : mango
当前水果 : banana
当前水果 : apple
当前水果 : mango
循环嵌套就是：while 里面还有 while，for里面还有个for
for iterating_var in sequence:
for iterating_var in sequence:
statements(s)
statements(s)
###################################
while expression:
while expression:
statement(s)
statement(s)
在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。
break 语句用来终止循环语句，如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。continue语句跳出本次循环，然后继续进行下一轮循环
break和continue是专门在循环中使用的关键字
break和continue只针对 当前所在循环 有效
九九乘法表
# 定义起始行
row = 1
# 最大打印 9 行
while row <= 9:
# 定义起始列
col = 1
# 最大打印 row 列
while col <= row:
# end = ""，表示输出结束后，不换行
# "\t" 可以在控制台输出一个制表符，协助在输出文本时对齐
print("%d * %d = %d" % (col, row, row * col), end="\t")
# 列数 + 1
col += 1
# 一行打印完成的换行
print("")
# 行数 + 1
row += 1
python中使用函数input()来接受用户从键盘输入的数据
x = input([提示字符串])注：无论用户输入 了任何类型的数据，input函数都会自动把他转换为字符串类型。如果程序需要获取其他类型的数据，可以使用eval()、int()、float()、complex()等类型转换函数。
input函数也可以直接接收用户输入的组合类型的数据，如列表、元组、集合、字典等，但如果用户一次输入多个数据，python会默认把这些数据看成一个元组
例：
x=input("输入姓名：") print(x,type(x)) y=int(input("输入年龄：")) print(y,type(y)) z=eval(input("输入成绩列表：")) print(z,type(z)) h,w=eval(input("输入身高体重用‘,‘分隔：")) print(h,w,type(h),type(w))输出：
输入姓名：lin lin <class ‘str‘> 输入年龄：22 22 <class ‘int‘> 输入成绩列表：[77,66] [77, 66] <class ‘list‘> 输入身高体重用‘,‘分隔：180,80 180 80 <class ‘int‘> <class ‘int‘>
python中使用内置函数
print()实现标准输出功能。基本格式：
print(输出项1[,输出项2，……，输出项n，sep=分隔符，end=结束符])
- 在默认情况下，
- 如果不希望末尾增加换行，可以在
, end=""- 其中
""中间可以指定例子：
print(1,2,3) print(1,2,3,sep=",") print(1,2,3,sep="\t") print(12,end="") print("*"*12,end="") print(21,end="")输出：
1 2 3 1,2,3 1 2 3 12************21
Python pass 是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句。
标签：集合 打印 多个 index 优先级 减法 start class 空间
原文地址：https://www.cnblogs.com/ice-point/p/14053732.html
