补充：python控制台输入函数— input（）函数 n = input（’请输入：’） 说明： 1、程序运行到input，会停下来，等待输入才继续执行 2、输入结束：遇到return就结束 3、获取的输入内容的类型是字符串（不管输入时什么）
程序执行中，只要遇到break，就结束包含break的最近的一个循环
练习：
#练习：随机生成一个整数，然后去猜，猜中为止
import random
number = random.randint(0,100)
count = 0
while True:
input_number = int(input('请输入0~100中想要输入的数字：'))
if input_number < number:
print('小了小了~~\n')
elif input_number == number:
print("恭喜你答对了！")
break
else :
print(' 大了大了~~\n')
结果：
请输入0~100中想要输入的数字：50
大了大了~~
请输入0~100中想要输入的数字：25
小了小了~~
请输入0~100中想要输入的数字：37
恭喜你答对了！
continue:循环执行到continue后，结束当次循环，跳转到下次循环
else：循环结束后要执行的代码
比如：
while 条件语句：
循环体
else：
循环后要执行的语句
格式：
print(*objects, sep=' ', end='\n', file=sys.stdout)
说明： objects –表示输出的对象。输出多个对象时，需要用 , （逗号）分隔。 sep – 用来间隔多个对象。 end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符。 file – 要写入的文件对象。
（1）、一个print（）打印完内容后，默认会换行。 （2）、一个print（）可以打印多个内容，多个内容之间用空格隔开。 （3）、设置一个print打印结尾结束后的样式（默认换行）。 end = 字符串 （4）、同时打印多个内容，中间的间隔（默认空格） sep = ‘ ‘
语法：
if 条件语句A：
语句块1
elif 条件语句B：
语句块2
else:
语句块3
说明： （1）. if 是python中关键字，用于判断条件 （2）. 结果转换成布尔值 （3）. 条件语句后有 “：”，必须写 （4）. 执行语句块的内容必须和 if 保持一个缩进
执行过程：先判断条件A语句的结果是否为True，如果是，则运行“语句块1”中的语句；反之，判断条件B语句的结果是否为True, 如果为真，运行“语句块2”中的语句；反之，执行 else 模块后的其他语句
if age >= 18:
print('成年可以进入网吧!')
else:
print("未成年，滚回去学习吧~~~")
练习：
# 产生一个随机数，判断是否是偶数，如果是，打印偶数，否则，打印奇数，若果能够被4整除，再打印‘ 能被4整除’
import random
number = random.randint(0,10000)
if number % 2 == 0:
print(number)
print ('偶数')
if number % 4 == 0:
print('能被4整除')
else :
print(number)
print('奇数')
结果：
5731
奇数
[Finished in 0.4s]
补充：
if number % 2 == 0 等价于 if not number % 2
完成某个功能时，需要重复某个操作，需要使用循环。
语法：
while 条件语句：
循环体
说明： A. while：关键字 B. 条件语句： 结果是True 或者 False C. 循环体 ： 要重复执行的代码
执行过程： 判断条件语句的结果是否为 True ， 如果为 True 就执行循环体 ， 执行完循环体再判断条件语句是否为 True ，直到条件语句的结果为 False 为止。
练习：
# 找大于10000中第一个能被47整除的数
x = 10000
while x % 47 :
x += 1
print('大于10000中的第一个能被47整除的数：%d'%x)
大于10000中的第一个能被47整除的数：10011
[Finished in 0.4s]
语法：
for 变量名 in 序列：
循环体
说明： A. for:关键字 B. 变量名： 和声明变量时的变量名的要求一样 C. in ： 关键字 D. 序列 ：容器 - 数据本身是由多个数据组成 ，例如字符串、字典、元祖 、集合 、range（）、生成式 、生成器 E. 循环体 ： 需要重复执行的代码
执行过程： 让变量去序列中取数据，取完为止。每取一个数据，执行一次循环体
range()函数是python中的内置函数，作用是产生一定范围的数字。 —-xrange（）是python2中的函数，python3中用range（）代替。 range（n，m，step）产生n ~ m-1 的所有数字，step为步进。
练习：
# 统计一下1~1000中能被3整除的数的个数
len = 0
for i in range(1,1001):
if not i % 3:
len += 1
i += 1
print('1~1000中能被3整除的数的个数为：%d'%len)
1~1000中能被3整除的数的个数为：333
[Finished in 0.4s]
1.优先选择 For 循环： （1）遍历序列的值 （2）循环次数确定 2.优先选择 While 循环： （1）死循环 （2）循环次数不确定
break 和 continue 放到循环体有特殊的功能
计算机以二进制的形式存储
(1).原码：数据的二进制形式
10 –> 1010 原码：00001010 -10 –> 原码：10001010
(2).反码
(3).补码
(1).需要显示转义字符，在前面加 \ 即可。
\\ —
计算字符串长度的时候，转义字符的长度是1
/n /t //
(2).如果需要同时转义多个字符，可以在字符串前面加 r 即可。
a = r'abcd\nsde\t'
print(a)
abcd\nsde\t #a
(3).python中字符的编码采用的是Unicode编码 A.Unicode编码包括了ASCII码。 B.Unicode是采用两个字节对一个字符进行编码（2^15）,将世界上所有符号进行编码。
Unicode和字符的转换 1).将Unicode码转换成字符：chr（编码）–
print(chr(0xAC00))
print(chr(0x4e60))
가
习
2)将字符转换成Unicode编码：ord（字符）
code1 = ord('星')
code2 = ord('辰')
print(hex(code1), hex(code2))
0x661f 0x8fb0
A. 怎么获取单个字符 python中的字符串，可以通过下标（索引）来获取指定位置上的字符：字符串[索引] 说明： a.字符串：可以是字符串值，也可以是字符串变量
b. []:中括号是固定语法
c.索引：从0开始到字符串长度减1（0对应第一个字符）；-1~-长度（-1对应最后一个字符）
注意：索引不能越界，否则越界！（产生异常）
str1 = 'abc' #a->0 , b->1 , c->2
print(str1[2])
c
B.获取部分字符串（获取子串） – 切片
注意： 步进如果是正数，那么下标1对应的位置必须在下标2的前面；如果步进为负数，那么下标1对应的位置必须在下标2的后面
下标2对应的字符是取不到的
说明：从下标1开始，获取到下标2前的所有字符
str2 = 'hello world'
print(str2[0:4])
print(str2[-4:-1])
hell
orl
说明：从下标1开始获取，每次下标值增加步进值，每增加一次取一次，直到取到下标2为止。
str2 = 'hello world'
print(str2[0:8:2])
hlow
[Finished in 0.3s]
切片的时候，下标1和下标2是可以省略
下标1省略：默认从开始的位置开始获取（可能是第一个字符，也可能是最后一个开始，取决于步进）
下标2省略：从下标1开始获取（同上）
效果如下：
str2 = 'hello world'
print(str2[:8:1])
print(str2[:8:-1])
print(str2[1::1])
print(str2[1::-1])
hello wo
dl
ello world
eh
[Finished in 0.3s]
hlowrdadpto [Finished in 0.3s]
## 5.字符串运算
**1.加法运算**
python支持两个字符串相加，效果就是将两个字符串拼接在一起产生一个新的字符串
print(‘abc’+’123’)
abc123 [Finished in 0.3s]
注意：“+”号的两边必须是同一类型
**2.乘法运算**
格式：字符串*整数
print(‘abc’ * 3)
abcabcabc [Finished in 0.2s]
**3.支持所有的比较运算符**
str1 = ‘abc’
print(‘abc’ == str1)
print(‘abcd’ > ‘ac’)
每一位依次比较其 Unicode码值大小
True False [Finished in 0.3s]
**4.in 和 not in**
'a' in 'abd' : 判断 'a' 是否在 'abd' 中
**判断结果为布尔值**
**5.获取字符串长度**
字符串长度 = 字符串个数
使用 len() 内置函数
str3 = ‘project’ print(len(str3))
7
补充：空串
str = ‘’ #长度是0
**6.阻止转义**
在字符串的最前面添加 r/R 可以阻止转义
print(r’a\nb’)
a\nb
**7.python为字符串提供了很多的內建函数**
**格式： 字符串.函数（）**
**这些所有函数的功能都不会影响原来的字符串，而是产生一个新的字符串**
A.capitalize()：将字符串第一个字符转换成大写
str1 = ‘hello world’ print(str1.capitalize())
Hello world [Finished in 0.2s]
B.center(width, fillchar) : 让字符串居中（width 宽度 ， fillchar 填充的字符）
print(‘abc’.center(10,’*’))
abc*
C.rjust(width , fillchar) : 让字符串局右（width 宽度 ， fillchar 填充的字符）
number = ‘1’ new_id = number.rjust(3,’0’) print(new_id)
001 [Finished in 0.2s]
同理 ljust（width，fillchar）左对齐
D. str.count(sub, start= 0,end=len(string))
统计次数（sub是搜索的子字符串，start和end分别是开始和结束位置）
print(‘adgfdsaaa’ .count(‘a’))
4
E.str1.join(str2)
在str2中的每个字符串之间插入一个str1
print(‘+’.join(‘abc’))
a+b+c
F. str1.replace(old, new,num)
将str1中的old全部替换成new(num表示替换前几个)
new_str = ‘abcdfdwdadfswqaqd’.replace(‘a’,’+’) print(new_str)
+bcdfdwd+dfswq+qd
## 6.字符串的格式化
**语法：'格式符' %（格式符对应的值）**
- 常见格式化字符：
- 格式化字符串 ---> %s
- 格式化数字 ---> %d
- 格式化浮点数 ---> %f
- 格式化字符 ---> %c （一般用于ascii码或者Unicode码）
first_name = ‘星’ last_name = ‘辰’ age = 18 newstr = ‘hello,%s%s!今年%d岁’ %(first_name,last_name,age) print(newstr)
hello,星辰!今年18岁 [Finished in 0.5s]
**%n.mf ：m表示显示的最小总宽度，n表示小数点位数**
a = 3434.12345 print(‘%8.4f’%a)
3434.1235 [Finished in 0.6s]
附：
## 7.数据类型转换
1.数据类型的自动转换
a = 10 #整型 b = 12.5 #浮点型 result = a+ b #浮点型–会自动转换整型为浮点型 ``` 2.强制转换 基本语法：类型名（数据）
其他类型 —> 浮点型 float(True) —> 1.0 去掉字符串的引号后，字符串的本身就是浮点数，才能转换成浮点型 float(‘2e3’) —> 2000.0
name.split(‘,’)
按照逗号分割(不写默认按照空格分割)
string.capitalize() 把字符串的第一个字符大写
string.center(width) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.decode(encoding=’UTF-8’, errors=’strict’) 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 ‘ignore’ 或 者’replace’
string.encode(encoding=’UTF-8’, errors=’strict’) 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’
string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
string.expandtabs(tabsize=8) 字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.format() 格式化字符串
string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
string.isdecimal() 如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit() 如果 string 只包含数字则返回 True 否则返回 False.
string.islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.isnumeric() 如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isspace() 如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle() 如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.ljust(width) 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.lower() 转换 string 中所有大写字符为小写.
string.lstrip() 截掉 string 左边的空格
string.maketrans(intab, outtab) maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str) 返回字符串 str 中最大的字母。
min(str) 返回字符串 str 中最小的字母。
string.partition(str) 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.rfind(str, beg=0,end=len(string) ) 类似于 find()函数，不过是从右边开始查找.
string.rindex( str, beg=0,end=len(string)) 类似于 index()，不过是从右边开始.
string.rjust(width) 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.rpartition(str) 类似于 partition()函数,不过是从右边开始查找.
string.rstrip() 删除 string 字符串末尾的空格.
string.split(str=””, num=string.count(str)) 以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串
string.splitlines([keepends]) 按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
在 string 上执行 lstrip()和 rstrip() string.swapcase()
翻转 string 中的大小写 string.title() 返回”标题化”的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
string.translate(str, del=””) 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
string.upper() 转换 string 中的小写字母为大写
string.zfill(width) 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0
string.isdecimal() isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。
特点：1.易于学习 2.易于阅读 3.易于维护 4.一个广泛的标准库 5.互动模式 6.可移植性 7.可扩展性 8.数据库 9.GUI编程 10.可嵌入
ctrl+/ 添加/取消注释 ctrl+s 保存 ctrl+c 复制 ctrl+x 剪切 ctrl+v 粘贴 ctrl+b 编译 ctrl+a 全选 ctrl+z 撤销 ctrl+shift+z 反撤销 ctrl+f 弹出搜索框 ctrl+n 新建 ctrl+shift+n 新建（工程） 按住shift点鼠标，可以选中部分内容
写代码的时候，一定是在英文输入的状态
注释是不会参与代码的编译和执行的，只是对代码进行解释和说明 单行注释：注释文字前加# 多行注释：3个单引号（双引号）前后包起来
要求 a.是由字母数字下划线（只能少不能多） b.数字表示开头的 c.大小写敏感 d.python3以后，标识符中可以包含非ASCII码（可以包含中文-不建议使用）
Python中用来作为特殊语法和拥有特殊功能的单词
查看关键字
import keyword
print (keyword.kwlist)
效果如下：
['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']
[Finished in 0.3s]
缩进的要求： 1.同一级的代码必须保持统一缩进（统一使用tab键来产生缩进） 2.通过缩进来产生代码块（类似其他语言中的{}） 行的规范： 1.声明函数的前后必须有两个换行 2.声明类的前后也需要两个换行 3.都个功能模块间用换行隔开
一行代码显示不完，不方便阅读时使用，不影响代码效果！ 1.语法：行末加反斜杠“\”即可
1000 + 2434543 - \
43643435 / 1000
2.列表、字典、元组和集合的字面量换行不用加“\”
[120,23,
'abc',
545,hehe]
1.数字字面量： 10,12.5，-20，+10.0,2e2 2.布尔值： True（真），False（假） 3.字符串：’proxy123’ , “hello” 4.列表： [10,20,’python’] 5.字典： {‘a’:10 , ‘name’:’xingchen’}
1.数字相关的： int（整型）， float（浮点型），complex（复数） 2.布尔 - bool 只有True ，False两个值 **3.字符串 - str **
a="abc"
4.列表 - list
a=['a','b',10]
5.字典 - dict
a={a:10 , b:20}
6.元组 - tuple
a= (10 , 20 ,'abc')
**7.集合 - set **
a = set(10,20,'abc')
8.函数 - function 9.字节 - bytes
声明变量及时在内存中开辟空间存储数据–变量就是存储数据
python是动态语言（不用声明数据类型） 1.怎么声明变量 格式：变量名 = 值
name = '路飞'
说明： 1.类型：不用确定 2.变量名：标志符，不能是关键字 –见名知义，PEP8命名规范（所有字母都小写，多个单词之间用“_”隔开）
class_name = "python1806"
如果申明一个变量，可以重新存储不同的数据类型
number = 100
number = '瑞文'
print (number)
效果如下：
瑞文
注：python中每条语句结束可以不用分号，但是如果一行需要写多条语句就必须加“ ； ”隔开。
number = 10 ; name = 'aaa'
同时声明多个变量，并且赋一样的值
str1 = str2 = str3 = 'abc'
使用print同时打印多个值
print(str1 , str2 , str3)
id（）—-查看变量的地址
先在内存中开辟空间存储数据，然后再将变量名作为数据对应内存的标签
例如：
a = 100
a = 10000
先把100存起来，再将其给予a的标签，所以a的地址发生变化
a = 100
print(id(a))
a = 10000
print(id(a))
打印地址如下：
1687149152
34333232
同理：
a = 100
print(id(a))
b = 100
print(id(b))
地址相同，如下：
1687149152
1687149152
所有的整数都是整型，python3中整型只有int，python2中整型有int和long
type() — 获取括号中的数据类型
所有带小数点的数字，都是浮点型
num1 = 0.12
num2 = -3.14
num3 = 2e2
print(type(num1),type(num3))
<class 'float'> <class 'float'>
[Finished in 0.3s]
布尔就是True和False True = 1 ； False = 0 —— ——
//(整除) ：
print(5//2)
2
%(取余):
print(5%2)
1
**（幂运算）:
print(2**3)
–练习–：
#取出一个4位整数的百位上的数是多少
a = 1343
num = a % 1e3
num = num // 1e2
print(num)
3.0
(大于) ； <(小于) ； ==(等于) ；!=(不等于) 所有比较运算的结果都是布尔值 ``` print(20 > 10) print(True == 1) print(False != 10)
True True True [Finished in 0.2s]
## 3.逻辑运算符
**and （与）**：两个 或者多个条件同时满足
**or（或）**： 只要一个为True，结果就为False
**not（非）**：返回结果与条件相反
**操作的数据是布尔值，返回的结果也是布尔值**
示例：
print(True and False)
score = 4 ; score2 = 91 print(score>3.5 or score2>=90)
age = 20 print(not age < 18)
False True True [Finished in 0.2s] ```
赋值符号： =（赋值），+=， -+ ， *=， /= , //= , *= , **=
赋值符号的左边必须是变量。
运算顺序：先运算赋值符号右边的值，然后将结果赋值给左边的变量。
a.变量 = 值
a = 10
b.变量 += 值
这儿的变量必须是已经声明过的变量
a += 2 #相当于 a = a + 2
注意：a += 2 地址不会变化
a = a+2 地址会变化
正负>数学运算符>比较运算符>逻辑运算符>赋值运算符 –优先级高的先计算，如果优先级相同，就从左往右依次计算，括号优先运算。
3.八进制和十六进制类似
python中内置进制转化方法 转换成二进制：bin（） 转换成八进制：oct（） 转换成十六进制：hex（）
特点：1.易于学习 2.易于阅读 3.易于维护 4.一个广泛的标准库 5.互动模式 6.可移植性 7.可扩展性 8.数据库 9.GUI编程 10.可嵌入
ctrl+/ 添加/取消注释 ctrl+s 保存 ctrl+c 复制 ctrl+x 剪切 ctrl+v 粘贴 ctrl+b 编译 ctrl+a 全选 ctrl+z 撤销 ctrl+shift+z 反撤销 ctrl+f 弹出搜索框 ctrl+n 新建 ctrl+shift+n 新建（工程） 按住shift点鼠标，可以选中部分内容
写代码的时候，一定是在英文输入的状态
注释是不会参与代码的编译和执行的，只是对代码进行解释和说明 单行注释：注释文字前加# 多行注释：3个单引号（双引号）前后包起来
要求 a.是由字母数字下划线（只能少不能多） b.数字表示开头的 c.大小写敏感 d.python3以后，标识符中可以包含非ASCII码（可以包含中文-不建议使用）
Python中用来作为特殊语法和拥有特殊功能的单词
查看关键字
import keyword
print (keyword.kwlist)
效果如下：
['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']
[Finished in 0.3s]
缩进的要求： 1.同一级的代码必须保持统一缩进（统一使用tab键来产生缩进） 2.通过缩进来产生代码块（类似其他语言中的{}） 行的规范： 1.声明函数的前后必须有两个换行 2.声明类的前后也需要两个换行 3.都个功能模块间用换行隔开
一行代码显示不完，不方便阅读时使用，不影响代码效果！ 1.语法：行末加反斜杠“\”即可
1000 + 2434543 - \
43643435 / 1000
2.列表、字典、元组和集合的字面量换行不用加“\”
[120,23,
'abc',
545,hehe]
1.数字字面量： 10,12.5，-20，+10.0,2e2 2.布尔值： True（真），False（假） 3.字符串：’proxy123’ , “hello” 4.列表： [10,20,’python’] 5.字典： {‘a’:10 , ‘name’:’xingchen’}
1.数字相关的： int（整型）， float（浮点型），complex（复数） 2.布尔 - bool 只有True ，False两个值 **3.字符串 - str **
a="abc"
4.列表 - list
a=['a','b',10]
5.字典 - dict
a={a:10 , b:20}
6.元组 - tuple
a= (10 , 20 ,'abc')
**7.集合 - set **
a = set(10,20,'abc')
8.函数 - function 9.字节 - bytes
声明变量及时在内存中开辟空间存储数据–变量就是存储数据
python是动态语言（不用声明数据类型） 1.怎么声明变量 格式：变量名 = 值
name = '路飞'
说明： 1.类型：不用确定 2.变量名：标志符，不能是关键字 –见名知义，PEP8命名规范（所有字母都小写，多个单词之间用“_”隔开）
class_name = "python1806"
如果申明一个变量，可以重新存储不同的数据类型
number = 100
number = '瑞文'
print (number)
效果如下：
瑞文
注：python中每条语句结束可以不用分号，但是如果一行需要写多条语句就必须加“ ； ”隔开。
number = 10 ; name = 'aaa'
同时声明多个变量，并且赋一样的值
str1 = str2 = str3 = 'abc'
使用print同时打印多个值
print(str1 , str2 , str3)
id（）—-查看变量的地址
先在内存中开辟空间存储数据，然后再将变量名作为数据对应内存的标签
例如：
a = 100
a = 10000
先把100存起来，再将其给予a的标签，所以a的地址发生变化
a = 100
print(id(a))
a = 10000
print(id(a))
打印地址如下：
1687149152
34333232
同理：
a = 100
print(id(a))
b = 100
print(id(b))
地址相同，如下：
1687149152
1687149152
所有的整数都是整型，python3中整型只有int，python2中整型有int和long
type() — 获取括号中的数据类型
所有带小数点的数字，都是浮点型
num1 = 0.12
num2 = -3.14
num3 = 2e2
print(type(num1),type(num3))
<class 'float'> <class 'float'>
[Finished in 0.3s]
布尔就是True和False True = 1 ； False = 0 —— ——
//(整除) ：
print(5//2)
2
%(取余):
print(5%2)
1
**（幂运算）:
print(2**3)
–练习–：
#取出一个4位整数的百位上的数是多少
a = 1343
num = a % 1e3
num = num // 1e2
print(num)
3.0
(大于) ； <(小于) ； ==(等于) ；!=(不等于) 所有比较运算的结果都是布尔值 ``` print(20 > 10) print(True == 1) print(False != 10)
True True True [Finished in 0.2s]
## 3.逻辑运算符
**and （与）**：两个 或者多个条件同时满足
**or（或）**： 只要一个为True，结果就为False
**not（非）**：返回结果与条件相反
**操作的数据是布尔值，返回的结果也是布尔值**
示例：
print(True and False)
score = 4 ; score2 = 91 print(score>3.5 or score2>=90)
age = 20 print(not age < 18)
False True True [Finished in 0.2s] ```
赋值符号： =（赋值），+=， -+ ， *=， /= , //= , *= , **=
赋值符号的左边必须是变量。
运算顺序：先运算赋值符号右边的值，然后将结果赋值给左边的变量。
a.变量 = 值
a = 10
b.变量 += 值
这儿的变量必须是已经声明过的变量
a += 2 #相当于 a = a + 2
注意：a += 2 地址不会变化
a = a+2 地址会变化
正负>数学运算符>比较运算符>逻辑运算符>赋值运算符 –优先级高的先计算，如果优先级相同，就从左往右依次计算，括号优先运算。
3.八进制和十六进制类似
python中内置进制转化方法 转换成二进制：bin（） 转换成八进制：oct（） 转换成十六进制：hex（）
在想要设置的标题的文字前面加#来表示，一个#是一级标记，二个#是二级标题，以此类推。共6级标题。
#这是一级标题
##这是二级标题
###这是三级标题
####这是四级标题
#####这是五级标题
######这是六级标题
效果如下： #这是一级标题 ##这是二级标题 ###这是三级标题 ####这是四级标题 #####这是五级标题 ######这是六级标题
-加粗 要加粗的文字左右分别用2个* 包起来 -斜体 要倾斜的文字左右用1个* 包起来 -斜体加粗 要倾斜和加粗的文字左右分别用3个* 包起来 -删除线 要加删除线的文字左右分别用2个~~包起来
示例：
**这是加粗的文字**
*这是倾斜的文字*
***这是斜体加粗的文字***
~~这是加删除线的文字~~
效果如下：
这是加粗的文字
这是倾斜的文字
这是斜体加粗的文字
这是加删除线的文字
在引用的文字前加>即可。可以嵌套，如加2个» 3个»>… 示例：
>这是引用的内容
>>这是引用的内容
>>>>>>这是引用的内容
效果：
这是引用的内容
这是引用的内容
这是引用的内容
三个或者三个以上的-或者*都可以实现
示例：
---
-----
***
*******
效果：
语法：
![图片alt](图片地址"图片title")
图片alt：显示在图片下的文字，用于对图片内容的解释
图片title：图片的标题
示例： [图片上传失败…(image-e3b85b-1534764999445)] 上传本地图片直接点击导航栏的图片标志即可
语法：
[超链接名](超链接地址 "超链接title")
代码：
[简书](http://jianshu.com)
[百度](www.baidu.com)
###-无序列表 ### 无序列表用- + *都可以
- 列表内容
+ 列表内容
* 列表内容
注意：序号和内容之间需要有空格
效果如下：
1. 列表内容
2. 列表内容
3. 列表内容
间隔需要有空格
效果如下：
语法：
表头|表头|表头
---|:--:|---:
内容|内容|内容
内容|内容|内容
姓名|技能|排行 —|:–:|—: 刘备|哭|大哥 关羽|打|二哥 张飞|骂|三哥
语法： 单行代码：代码之间分别用一个反引号包起来
`代码内容`
代码块之间分别用三个反引号抱起来，并且两边的反引号单独占一行
（```）
代码...
代码...
代码...
（```）
注：为了防止转译，前后三个反引号处加了小括号，实际是没有的。这里只是用来演示，实际中去掉两边小括号即可。