1. 计算机基础

1.1 计算机系统

cpu：中央处理器，相当于人的大脑，运算中心，控制中心。

内存：暂时存储数据，与CPU交互

优点：读取速度快；

缺点：容量小，造价高，断电即消失。

硬盘：长期存储数据

优点：容量大，成本低，断电不消失。

确定：读取速度慢。

操作系统：调控统领这些过程。

1.2 计算机存储

8 bit == 1 bytes （ 8位 = 一个字节）

1024 bytes == 1kb

1024 kb == 1 MB

1024MB == 1 GB

1024 GB == 1 TB

1024TB == 1TB

2. 初识Python-发展历史、数据类型、基本语法

2.1 Python 发展历史

2008年python同时更新了两个版本

2.1.1 python2x 和 python3x 不同

python 2x：源码不规范，重复性代码比较多。

python 3x：源码清晰，优美，简单。

源代码（也称源程序）是指未编译的按照一定的程序设计语言规范书写的文本文件，是一系列人类可读的计算机语言指令。计算机源代码的最终目的是将人类可读的文本翻译成为计算机可以执行的二进制指令，这种过程叫做编译，通过编译器完成。

2.2.2 编程语言的分类

1. 编译型：将代码一次性全部编译成字节码，再执行。
，   代表语言：C
       优点：执行速度快。
       缺点：不能跨平台，开发速度慢。
           开发速度慢。
           不好调试。
2. 解释型：代码从上至下逐行解释并运行。
       代表语言：python。
       优点：便于调试。
           可以跨平台。
           开发效率高。
       缺点：
           执行速度相对慢。

	解释性语言和编译型语言
	解释性语言	编译型语言
概念	计算机不能直接的理解高级语言，只能直接理解机器语言，所以必须要把高级语言翻译成机器语言，计算机才能执行高级语言的编写的程序。翻译的方式有两种，一个是编译，一个是解释。两种方式只是翻译的时间不同
特征	代码从上至下逐行解释并运行。通常不用对源代码进行编译，一般是通过解释器载入脚本后运行。由于每个语句都是执行的时候才进行解释翻译，这样解释性语言每次执行就要翻译一次，效率相对要低。	将代码一次性全部编译成字节码，再执行。编译型语言先要进行编译，然后转为特定的可执行文件，这个可执行文件是针对平台的（CPU类型），可以这么理解你在PC上编译一个C源文件，需要经过预处理，编译，汇编等等过程生成一个可执行的二进制文件。当你需要再次运行该代码时，不需要重新编译代码，只需要运行该可执行的二进制文件。
代表	解释型语言代表有：`JavaScrip`t、`Python`、`Erlang`、`PHP`、`Perl`、`Ruby`	编译型语言代表有：`C`语言，`C++`、`Object-C`以及最近很火的苹果新语言`swift`
优点	便于调试；可以跨平台；开发效率高。	执行速度快。因为编译只做一次，运行时不需要编译，所以编译型语言的程序执行效率高。可以脱离语言环境独立运行。
缺点	执行速度相对慢。每次运行的时候都要解释一遍，性能上不如编译型语言。	不能跨平台；开发速度慢；不好调试。编译的时候根据对应的运行环境生成机器码，不同的操作系统之间移植就会有问题，需要根据运行的操作系统环境编译不同的可执行文件。

参考：https://www.jianshu.com/p/bd3d7005de43

2.2 python的优缺点

优点：优雅，明确，简答；大量的基础代码库和第三方库。

缺点：运行速度慢；代码无法加密（因为是python是解释型语言，所有发布Python程序实际上就是发布源代码，而C语言则是把编译后的机器码（.exe文件）发布出去。

2.3 python 解释器的种类

CPython是使用最广的Python解释器。如果要和Java或.Net平台交互，最好的办法不是用Jython或IronPython，而是通过网络调用来交互，确保各程序之间的独立性。

2.4 python的环境。

1.安装时自动配置环境变量：勾选“Add pthon to path"

2.手动配置环境变量；

2.5 运行第一个python代码

2.6 变量

#print("hello 每个人")
#print(1+2+3+4+5)
#print((1+2+3+4+5)*20/4)
#print(((1+2+3+4+5)*20/4)*5/2)
x = 1+2+3+4+5
#print(x)
y = x * 20 / 4
z = y * 5 / 2
#print(y,z)

# x y z 就是变量：变量就是将一些数据的中间结果暂存起来，以便后续程序调用。

2.6.1 变量命名规范：

1,变量只能由数字，字母，下划线任意组合。
2，不能以数字开头。
3，不能是python中的关键字。
['and', 'as', 'assert', 'break', 'class', 'continue',
'def', 'del', 'elif', 'else', 'except', 'exec',
'finally', 'for', 'from', 'global', 'if', 'import',
'in', 'is', 'lambda', 'not', 'or', 'pass', 'print',
'raise', 'return', 'try', 'while', 'with', 'yield']
4，变量要有描述性。
   name = 'alex'
   age = 'taibai'
5，变量不能使用中文。
6，变量不能过长。
   fdjksaflsdsfdfjkl = 'wusir'
7, 变量不能使用拼音。

8，官方推荐使用：
   驼峰体
   AgeOfOldboy = 1000
   下划线
   age_of_oldboy = 1000

# 变量的练习题：
'''
1age = 2 # False
a_ = 45  # True
_ = 123  # True
_$ = 333  # False 有$特殊字符
__ = 'alex'  # True
123 = 666  # False
a1b = 45  # True
_ _ = 6666  # False

2.6.2变量在哪里应用：
# 过长的结果，我让变量代替，使用起来方便，清晰。
# 减少重复率。

2.7 常量

常量:一直不变的量。python中本来没有常量。

#python中的常量：将变量全部大写。

# 往往常量会放在文件最上面。

2.8 注释

注释：对代码解释说明，帮助自己或者别人理解。

1. 单行注释：#

# 注释内容

2. 多行注释：‘’‘被注释内容''' """被注释内容”“”

'''注释内容
'''

2.9 基本数据类型

人类给机器划分的一些数据：数字类型，字符串类型，bool值，等等。

2.9.1数值

1. float 浮点型

2. int 整型

判断十进制的数字转换为二进制后的有效位数

i = 40
print(i.bit_length())

（1）十进制二进制转换

十进制整数转换为二进制整数：采用"除2取余，逆序排列"法。具体做法是：用2整除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为小于1时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。

十进制小数转换成二进制小数：采用"乘2取整，顺序排列"法。具体做法是：用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，此时0或1为二进制的最后一位。或者达到所要求的精度为止。

3. 布尔值 True、False

布尔值就两种：True，False。表示条件的正确与否。

真 1 True。

假 0 False。

4. int str bool 三者数据类型之间的转换

str(), int(), bool()

str 转换为 bool，非空时为Ture，否则为False。

name = input(">>>")
if name:print("已输入")
else:print()print("无输入")

2.9.2 字符串（str）

1. 什么是字符串？

字符串是由零个或多个字符组成的有限序列（维基百科定义）。而在Python 3中，它有着更明确的意思：字符串是由Unicode码点组成的不可变序列（Strings are immutable sequences of Unicode code points）。

python 中凡是用引号（英文单引号、双引号、三引号）引起来的就是字符串。

（1）字符串的创建：

s1 = ' alex's2 = 'alex李哥'# 单双引号配合使用s3 = " I’m 12 years old "
print (s3)
msg = """ 窗前明月光，
疑是地上霜"""
# 换行的字符串需要用三个引号括起来
print (s1 + s2)
#字符串可以与字符串拼接
print (s1*5)

如果字符串内部既包含'又包含"怎么办？可以用转义字符\来标识。

print ('I\'m \"OK\"!')

\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\。

如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''...'''的格式表示多行内容

print('''line1
line2
line3''')

（2）字符串拼接

x = "Hello, "
y = "world!"
x + y

（3）长字符串

要表示很长的字符串（跨越多行的字符串），可使用三引号（单双引号都可）。

>>> print('''"How are you?"
... "I'm fine"
... ''')
"How are you?"
"I'm fine"

提示：常规字符串也可横跨多行。只要在行尾加上反斜杠，反斜杠和换行符将被转义，即被忽略。此时，代码是多行呈现，而实际打印效果并不是多行呈现。

>>> print ('Hellw, \
... world!')
Hellw, world!

这种处理手法也适用于表达式和语句，可将一条语句在多行书写。

>>> 1 +2 + \
... 4 + 5
12
>>> print \
... ( 'Hello, world')
Hello, world

（4）原始字符串

由于反斜杠\ 的特殊意义，在表示路径时，将面临大量的发斜杠进行转义。

path = 'C:\\Program Files\\fnord\\foo\\bar\\baz\\frozz\\bozz'

在这样的情况下，原始字符串可派上用场，因为它们根本不会对反斜杠做特殊处理，而是让字符串包含的每个字符都保持原样。

>>> print(r'C:\Program Files\fnord\foo\bar\baz\frozz\b')
C:\Program Files\fnord\foo\bar\baz\frozz\b

不过，原始字符串不能以单个反斜杠结尾。

2. 字符串的索引与切片

字符串作为序列的一种，同所有序列一样，都可执行索引、切片、相加、相乘和成员资格检查。

序列中的所有元素都有编号——从0开始递增，我们使用编号来访问各个元素，这称为索引（indexing）。

除使用索引来访问单个元素外，还可使用切片（slicing）来访问特定范围内的元素。

可使用加法运算符来拼接序列。

将序列与数x相乘时，将重复这个序列x次来创建一个新序列。

内置函数len、min和max很有用，其中函数len返回序列包含的元素个数，而min和max分别返回序列中最小和最大的元素

要检查特定的值是否包含在序列中，可使用运算符in。它检查是否满足指定的条件，并返回相应的值：满足时返回True，不满足时返回False。这样的运算符称为布尔运算符，而前述真值称为布尔值

（1）字符串从左向右按序排列，第一个字符的索引（下标）是0，向右依次类推。

索引的表示：

a = 'ABCDEFGHIJK'
print(a[0])
print(a[3])
print(a[5])
print(a[7])

（2）切片就是通过索引（字符串[索引1：索引2：步长]）截取字符串的一段，注意截取的字符串从索引1 至索引2的前一个字符（原则就是顾头不顾腚）形成新的字符串。

a = 'ABCDEFGHIJK'
print(a[0:3])  # print(a[:3]) 从开头开始取0可以默认不写
print(a[2:5])
print(a[:]) #默认到最后
print(a[:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(a[:5:2]) #加步长print(a[-1:-5:-2]) #反向加步长

3. 字符串的常用方法

字符串常用操作方法	效果
capitalize()	首字母大写，其他字母小写
center()	字符串剧中，前后充填自定义字符
lower()
upper()
startwith()
swapcase()

name = 'oldboy'
# capitalize() 首字母大写,其余字母小写
print(name.capitalize())
# center 字符串居中，前后填充自定义字符
print(name.center(20, '*'))
# upper lower *****
print(name.upper())
print(name.lower())
# 应用举例：判断用户输入的验证码是否正确
code = 'Adfer'
print('请输入验证码：' + code)
youcode = input('请输入验证码：')
if youcode.upper() == code.upper():print('输入成功')
# startswith() 判断是否以...为开头 *****
print(name.startswith('o'))
print(name.startswith('ol'))
print(name.startswith('b', 3, 5))
#大小写转换
print(name.swapcase())
#tille() 非字母隔开的每个部分的首字母大小。
s1 = 'alex wusir*taibai'
print(s1.title())
#tille() 非字母隔开的每个部分的首字母大小。
s1 = 'alex wusir*taibai'
print(s1.title())
print()
# find() 通过元素寻找索引，找到第一个元素就返回其位置。找不到返回-1。*****
print(name.find('b'))
print(name.find('bo'))
print(name.find('b', 1, -1 ))
# index() 通过元素寻找索引，找到第一个元素就返回其位置。找不到则报错
#print(name.index('x'))
# strip() 默认去除字符串前后的空格，换行符，制表符.
name1 = '\t   oldboy\n'
print(name1)
print(name1.strip())
name2 = 'apple phone\' apple logo like a bite of an apple'
print(name2.strip("apple")) # 可以从字符串首尾开始去除指定的字符，直到指定字符被其他字符阻挡。
# strip() 应用举例：
username = input('请输入用户名：').strip()
if username == 'alex':print('登陆成功')
# lstrip() 和rstrip()
# split 将字符串分割成列表，默认按照空格分割。
s1 = 'alex taibai'
l1 = s1.split()
print(l1)
s2 = 'alex，taibai'
l2 = s2.split('，')
print(l2)
s3 = ' alex taibai'
print(s3.split()) # 默认以空格为分隔符时，有一个bug，第一个空元素为被分割出来。
print(s3.split(' ')) # 输入空格时，可以将空元素分割出来。
s4 = ', alex, taibai'
print(s4.split(','))
print(s4.split('l', 1)) #可设置分割次数
# join 自定义连接符，将可迭代对象种的元素连接起来；可将列表转化为字符串。*****
str1 = 'alex'
s2 = '*'.join(str1)
print(s2)
# replace 替换 *****
str2 = 'alex 是创始人，alex很nb'
s3 = str2.replace('nb', 'sb')
print(s3)
# is系列
name = 'sunhao'
print(name.isalnum())# 判断字符串是否由数字或字母组成
name1 = '123'
print(name1.isdigit()) # 判断字符串是否全部由整数组成
print(name.isalpha()) # 判断字符串是否全部由字母组成

公共的一些方法：

name = 'sunhao'
print(name.count('a')) #判断字符出现次数
# 字符串长度
print(len(name))
# 例子：依次打印出name的每个字符
count = 0
while count < len(name):print(name[count])count += 1

例子：

当name = 'aleX leNb'，请输出 name 变量对应的值中 "e" 所在索引位置?

name = "aleX leNb"
# 方式1
print(name.index('e'))
print(name.index('e', name.index('e')+1))
# 方式2
count = 0
while count < len(name):if name[count] == 'e':print(count)count += 1

实现一个整数加法计算器(两个数相加)：如：content = input("请输入内容:") 用户输入：5+9或5+ 9或5 + 9，然后进行分割再进行计算。

content = input('请输入内容：').strip()
num_list = content.split('+')
print('{} + {} = '.format(int(num_list[0]), int(num_list[1])) + str(int(num_list[0]) + int(num_list[1])))

2.9.3 列表

python提供了一类数据类型，他能承载多种数据类型，这类数据类型被称作容器类的数据类型。列表就属于容器类的数据类型，以[ ]括起来, 每个元素用' , '隔开而且可以存放各种数据类型。其他编程语言也有类似的数据类型，比如JS中的数组，java中的数组等等。

什么是容器？

Python支持一种数据结构的基本概念，名为容器（container）。容器基本上就是可包含其他对象的对象。两种主要的容器是序列（如列表和元组）和映射（如字典）。在序列中，每个元素都有编号，而在映射中，每个元素都有名称（也叫键）。还有一种既不是序列也不是映射的容器，它就是集合（set）。

什么是序列？

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

1. 列表的创建

（1）以[ ]括起来, 每个元素用' , '隔开

l1 = [1, 2, '太白']

（2）使用字符串来创建列表，方式：函数list（实际上是一个类），

# 将字符串转化为字符列表
>>> list('Hello')
['H', 'e', 'l', 'l', 'o']

可将任何序列（而不仅仅是字符串）作为list的参数。

另外，如果要将字符列表（如前述代码中的字符列表）转换为字符串，可使用下面的表达式：

''.join(somelist)

其中somelist是要转换的列表。

s3 = list('Hellow')
print(s3)
s4 =''.join(s3)
print(s4)

2. 基本的列表操作

（1）列表的索引、切片

（2）删除元素

pop 按照索引删除

l1 = ['alex', 'wusir', 'taibai', 'ritian']
print(l1.pop(0)) # 返回值为删除的元素
print(l1)

remove 按照元素删除

l1 = ['alex', 'wusir', 'taibai', 'ritian']
l1.remove('alex')
print(l1)

全部删除（清空）

l1 = ['alex', 'wusir', 'taibai', 'ritian']
l1.clear()
print(l1)

del

可以按照索引删除

>>> name = ['sunhao', 'wangjingjing', 'sushi']
>>> del name[2]
>>> name
['sunhao', 'wangjingjing']

可以按照切片删除

>>> name = ['sunhao', 'wangjingjing', 'sushi']
>>> del name[:2]

可以在内存级别删除整个列表

l1 = ['alex', 'wusir', 'taibai', 'ritian']
del l1

(3) 增加元素

append 追加

增添新员工：

name_list = ['赵三', '李四']
while 1:username = input("输入新员工姓名：").strip()if username.upper() == 'Q':breakname_list.append(username)
print(name_list)

insert 插入

 Insert object before index.

l1 = ['alex', 'wusir', 'taibai', 'ritian']
l1.insert(1, '王五')
print(l1)

extend 迭代追加

 Extend list by appending elements from the iterable.

>>> l1 = ['alex', 'wusir', 'taibai', 'ritian']
>>> l1.extend(['李四', '王二麻子'])
>>> print(l1)
['alex', 'wusir', 'taibai', 'ritian', '李四', '王二麻子']
>>> l1.extend('abc')
>>> print(l1)
['alex', 'wusir', 'taibai', 'ritian', '李四', '王二麻子', 'a', 'b', 'c']

（4）修变列表

按照索引改

l1 = ['alex', 'wusir', 'taibai', 'ritian']
l1[0] = '王五'
print(l1)

按照切片改

>>> x = list('aaaa')
>>> x[2:] = list('bcdefg')
>>> x
['a', 'a', 'b', 'c', 'd', 'e', 'f', 'g']

不替换原有元素的情况下插入新元素

>>> x = list('1234456')
>>> x
['1', '2', '3', '4', '4', '5', '6']
>>> x[2:2] = ['8','8','8']
>>> x
['1', '2', '8', '8', '8', '3', '4', '4', '5', '6']

按照切片＋步长

l1 = ['alex', 'wusir', 'taibai', 'ritian']
l1[0:3:2] = ['w', 'r']
print(l1)

（4）列表查询

切片索引
for循环

（5）其他

len()
count()
index() # 通过元素查找索引
sort() #当列表都是由数字组成时，将数字从小到大排序
sort(reverse = Ture) # 从大到小进行排序
reverse() #反转

2.9.4 tuple 元组

2.9.5 dict 字典

大量的关联型数据。

2.9.6 set 集合

2.10 输入和输出

2.10.1 输入： input 全部是字符串类型。

#input 出来的数据全部都是字符串类型
name = input('请输入用户名：')
print (name)
print (type(name)) # 判断此数据的类型
print ("此用户的姓名是：" + name)

数据类型的转化：
int()  字符串转换为数字时，字符串必须全部由数字组成。
str()

2.11 流程控制语句if

if 条件:
执行结果

当语句以冒号:结尾时，缩进的语句视为代码块。但python没有规定缩进几个空格或Tab，按约定俗成的习惯，应使用四个空格的缩进。在文本编辑器中，需要设置把Tab自动转换为4个空格，确保不混用Tab和空格。

需要注意tab缩进在不同的操作系统当中会有不同的缩进，造成A程序在win系统可以，linux就不能用，反过来可能也会造成相同的问题。那么我就是想用tab怎么办呢？以notepad++为例，在配置中可以将tab缩进设置成用4个空格来代替，这样就保证了不同操作系统下缩进的统一。

2.11.1 单独If

if 条件:代码块

if 3 > 2 :print(222)
print (333)

2.11.2 if else

if 条件:

执行结果

else:

执行结果

if 条件:代码块
else：代码块


choice = int(input('请输入你猜得大小：'))
if 0<choice< 4:print ('你猜得是小')
else:print ('你猜得是大')

2.11.3 多个条件选一个

if 条件:代码块
elif 条件:代码块
elif 条件:代码块
else代码块

choice = int(input('请输入你猜得大小：'))
if 0<choice< 4:print ('你猜得是小')
else:print ('你猜得是大')choice = int (input('请输入你猜的数字: '))
if choice == 1:print ( '我请你吃饭')
elif choice == 2 :print ( '我请你喝酒')
elif choice == 3:print ( '我请你吃棒棒糖')

2.11.4 if 嵌套

username = input('请输入用户名：')
password = input ('请输入密码：')
if username == 'alex':if password == '123':print ('登录成功')else:print ('密码错误')
else:print ('用户名输入错误')

2.12 while 循环

'''
while 条件:循环体  '''

while True: # 死循环。判断条件为真，进入循环体print('大悲咒')print('两只老虎')print('霸王别姬')print('老司机带带我')# 代码执行底部后，返回继续判断条件。

#如何终止循环？
# 1. 改变条件（标志位的概念）
flag = True
while flag:print('大悲咒')print('两只老虎')print('霸王别姬')print('老司机带带我')flag = False
# 2. break 循环中只要遇到break 立马结束循环
flag = True
count = 1
while flag:print(count)count = count +1if count == 101:break
# 计算1+2+3+...+100
sum = 0
count =1
while Ture:sum = sum + countcount = count +1if count == 101:print(sum)break

#continue 结束本次循环，继续下一次循环

while 条件语句:

代码块

else:

代码块

如果while 循环被break打断，则不执行else代码

>>> count = 1
>>> while count < 4:
...     print(count)
...     count += 1
...     break
... else:
...     print(666)
...
1

while 循环应用场景：1. 验证用户名、密码，重新输入的过程需要while循环。2. 无限次显示页面，无限次输入等。

2.12’ for 循环

如果对一个数据类型进行循环，或者是一个有限次数循环的时候，通常要用到for。

# for 变量 in iterable（可迭代对象：多个元素组成的数据）
#for 循环的次数是和和迭代对象的元素个数有关
i = 'abcdefgh'
for i in s1: print(i）

2.13 格式化输出

制作一个模板，某些位置的参数时动态的，这时就需要格式化输出。如下：

2.13.1 占位符方式

1. 整数输出

%o —— oct 八进制
%d —— dec 十进制
%x —— hex 十六进制

print('输出数字是：%d' % 20)
print('输出数字是：%o' % 20)
print('输出数字是：%x' % 20)
'''
输出数字是：20
输出数字是：24
输出数字是：14
'''

2. 浮点数输出

%f ——保留小数点后面六位有效数字
　　%.3f，保留3位小数位
%e ——保留小数点后面六位有效数字，指数形式输出
　　%.3e，保留3位小数位，使用科学计数法
%g ——在保证六位有效数字的前提下，使用小数方式，否则使用科学计数法
　　%.3g，保留3位有效数字，使用小数或科学计数法

>>> print('%f' % 1.11)  # 默认保留6位小数
1.110000
>>> print('%.1f' % 1.11)  # 取1位小数
1.1
>>> print('%e' % 1.11)  # 默认6位小数，用科学计数法
1.110000e+00
>>> print('%.3e' % 1.11)  # 取3位小数，用科学计数法
1.110e+00
>>> print('%g' % 1111.1111)  # 默认6位有效数字
1111.11
>>> print('%.7g' % 1111.1111)  # 取7位有效数字
1111.111
>>> print('%.2g' % 1111.1111)  # 取2位有效数字，自动转换为科学计数法
1.1e+03

3、字符串输出

%s
%10s——右对齐，占位符10位
%-10s——左对齐，占位符10位
%.2s——截取2位字符串
%10.2s——右对齐，10位占位符，并截取两位字符串

>>> print('%s' % 'hello world')  # 字符串输出
hello world
>>> print('%20s' % 'hello world')  # 右对齐，取20位，不够则补位hello world
>>> print('%-20s' % 'hello world')  # 左对齐，取20位，不够则补位
hello world
>>> print('%.2s' % 'hello world')  # 取2位
he
>>> print('%10.2s' % 'hello world')  # 右对齐，取2位he
>>> print('%-10.2s' % 'hello world')  # 左对齐，取2位
he
>>> print('你的身份证地区代码是：%10.4s' %'371327199402051532')
你的身份证地区代码是：      3713

name = input('请输入姓名：')
age = int(input('请输入年龄：'))
sex = input('请输入性别：')
#%是占位符(占位符就是先占住一个固定的位置，等着你再往里面添加内容的符号，广泛用于计算机中各类文档的编辑)
#s表示数据类型为字符串，d表示数据类型为数字，
# 第一种方式
msg = '你的名字是%s，你的年龄%d，你的性别是%s。' % (name, age, sex)
print(msg)
# 第二种方式
msg = '你的名字是%(name1)s，你的年龄是%(age1)d，你的性别是%(sex1)s。' %{'name1': name, 'age1': age, 'sex1': sex}
print(msg)
#bug点 在格式化输出中，想输入文本%时，应该用%%表示。
msg = '我叫%s，今年%d，我的学习进度是1%%'%('张三', 22)
print(msg)

2.13.2 format 方式

format()功能更强大，该函数把字符串当成一个模板，通过传入的参数进行格式化，并且使用大括号‘{}’作为特殊字符代替‘%’

#第一种
s2 = '我叫{}'.format('sunhao')
print(s2)
#第二种
s3 = '我叫{0}，今年{1}'.format('sunhao', '23')
print(s3)
# 第三种
s4 = '我叫{name}，今年{age}'.format(age = '23', name = 'sunhao')
print(s4)

2.14 运算符

2.14.1 算数运算

假设变量：a=10，b = 20.

2.14.2 比较运算

假设变量：a=10，b=20

2.14.3 赋值运算

以下假设变量：a=10，b=20

2.14.4 逻辑运算

逻辑运算符的优先级（计算顺寻的先后，优先级高的先计算）：（）> not > and > or

1. 第一种情况，运算符两侧是比较运算

print(1 < 2 or 3 > 1)
print(1 < 2 and 3 > 4)
print(1 < 2 and 3 > 4 or 8 < 6 and 9 > 5 or 7 > 2)
print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8)
print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6)

2. 第二种情况，运算符两侧是数值x or y if x is True,return x
x or y，与x or y正好相反# 补充
# int < --- > bool
# 0 对应的bool值为False,非0 都是True.
# True 1 ,False 0

print(1 > 2 or 3 and 4 < 6)
# True
print(2 or 3 and 4 < 6)
# 2

应用：1. if 、while 等条件判断（数据库，Django orm Q查询)

3. 混合运算

1 or 3 and 4 < 6

2.14.5 成员运算符

判断子元素是否在原字符串（字典，列表，集合）中。

#print('喜欢' in 'dkfljadklf喜欢hfjdkas')
#print('a' in 'bcvd')
#print('y' not in 'ofkjdslaf')

2.14.6 运算符优先级

以下所列优先级顺序按照从高到低优先级的顺序；同行为相同优先级

print(3 <= 4 == 4 >= 1 and 3 < 5 == 3 == 3)
print(int(3 < 5))
print(True == bool(4))
print(True == 4)

2.15 编码初识

ASCII

Unicode

utf-8

GBK

表示范围

英文字母，数字以及特殊字符

全世界所有的文字

中文、英文字母，数字，特殊字符

字符占用空间

一个字符最多只能用 8 位，即一个字节来表示

起初：1个字符用16位，即 2个字节表示。

改版：1个字符 32位 4个字节表示

一个字符最少用8位，即一个字节表示。Ascii码中的内容用1个字节保存，欧洲的字符用2个字节保存，东亚的字符用3个字节保存。

英文字符占用一个字节；

中文字符占用两个字节

2.15.1 ASCII码

ASCII码（American Standard Code for Information Interchange，美国标准信息交换代码）是基于拉丁字母的一套电脑编码系统ASCII码中只包含英文字母，数字以及特殊字符与二进制的对应关系，主要用于显示现代英语和其他西欧语言，其最多只能用 8 位来表示（一个字节），即：2**8 = 256，所以，ASCII码最多只能表示 256 个符号。

随着计算机的发展以及普及率的提高，这时ASCII码就不合适了。比如: 中⽂汉字有几万个，而ASCII只有256个位置。这时, 不同的国家就提出了不同的编码用来适用于各自的语言环境（每个国家都有每个国家的GBK，每个国家的GBK都只包含ASCII码中内容以及本国自己的文字）. 比如, 中国的GBK, GB2312, BIG5, ISO-8859-1等等. 这时各个国家都可以使用计算机了.

2.15.2 GBK

GBK：只包含中文以及英文字母，数字，特殊字符与字节的对应关系。

对于ASCII码中的内容，GBK完全沿用的ASCII码，所以一个英文字母（数字,特殊字母）用一个字节表示，而对于中文来说，一个中文用两个字节表示。

英文：占用一个字节

中文：占用两个字节

但是，随着全球化的普及，由于网络的连通，以及互联网产品的共用（不同国家的游戏，软件，建立联系等），各个国家都需要产生各种交集，此时急需一个密码本：要包含全世界所有的文字与二进制0101010的对应关系，所以需要一个包罗万象的万国码。

2.15.3 Unicode

Unicode：包含全世界所有的文字与二进制0101001的对应关系。

Unicode起初：1个字符 16位 2个字节表示。
Unicode改版：1个字符 32位 4个字节表示。

查看当前Python种表示Unicode字符时占用的空间：

import sys
print(sys.maxunicode)
# 如果值是65535，则表示使用ucs2标准，即：2个字符表示
# 如果值是114111，则表示使用ucs4标准，即：4个字符表示

2.15.4 UTF-8

UTF-8:包含全世界所有的文字与字节的对应关系（最少用8位一个字节表示一个字符）。

Unicode编码标准于1991年推出，至今迭代到了第11版，已经能够编码146个书写系统的130000个字符，可谓是无所不包，真不愧是“国际码”。Unicode编码其实是一个二进制字符集，它建立了从书写字符映射成唯一的数字字符的关系，但是，由于各系统平台对字符的理解差异，以及出于节省空间的考虑，Unicode编码还需要再做一次转换，转换后的新的二进制数字才能作为实际存储及网络传输时的编码。

这种转换方式被称为Unicode转换格式（Unicode Transformation Format，简称为UTF），它又细分为UTF-8、UTF-16、UTF-32等等方式。我们最常用的是UTF-8。为什么UTF-8最常用呢？因为它是可变长度的编码方案，针对不同的字符使用不同的字节数来编码，例如编码英文字母时，只需要一个字节（8个比特），而编码较复杂的汉字时，就会用到三个字节（24个比特）。

即UTF-8是对Unicode编码的压缩和优化，他不再使用最少使用2个字节，而是将所有的字符和符号进行分类：Ascii码中的内容用1个字节保存，欧洲的字符用2个字节保存，东亚的字符用3个字节保存...

如'old男孩'：占用9个字节

2.15.5 GBK 与UTF-8之间如何转换？

Pythton学习笔记1相关推荐

PyTorch 学习笔记（六）：PyTorch hook 和关于 PyTorch backward 过程的理解 call
您的位置首页 PyTorch 学习笔记系列 PyTorch 学习笔记(六):PyTorch hook 和关于 PyTorch backward 过程的理解发布: 2017年8月4日 7,195阅读 ...
容器云原生DevOps学习笔记——第三期：从零搭建CI/CD系统标准化交付流程
暑期实习期间,所在的技术中台-效能研发团队规划设计并结合公司开源协同实现符合DevOps理念的研发工具平台,实现研发过程自动化.标准化: 实习期间对DevOps的理解一直懵懵懂懂,最近观看了阿里专家带 ...
容器云原生DevOps学习笔记——第二期：如何快速高质量的应用容器化迁移
暑期实习期间,所在的技术中台-效能研发团队规划设计并结合公司开源协同实现符合DevOps理念的研发工具平台,实现研发过程自动化.标准化: 实习期间对DevOps的理解一直懵懵懂懂,最近观看了阿里专家带 ...
2020年Yann Lecun深度学习笔记（下）
2020年Yann Lecun深度学习笔记(下)
2020年Yann Lecun深度学习笔记（上）
2020年Yann Lecun深度学习笔记(上)
知识图谱学习笔记（1）
知识图谱学习笔记第一部分,包含RDF介绍,以及Jena RDF API使用知识图谱的基石:RDF RDF(Resource Description Framework),即资源描述框架,其本质是一个 ...
计算机基础知识第十讲,计算机文化基础（第十讲）学习笔记
计算机文化基础(第十讲)学习笔记采样和量化PictureElement Pixel(像素)(链接: 采样的实质就是要用多少点(这个点我们叫像素)来描述一张图像,比如,一幅420x570的图像,就表示 ...
Go 学习推荐 —（Go by example 中文版、Go 构建 Web 应用、Go 学习笔记、Golang常见错误、Go 语言四十二章经、Go 语言高级编程）
Go by example 中文版 Go 构建 Web 应用 Go 学习笔记:无痕 Go 标准库中文文档 Golang开发新手常犯的50个错误 50 Shades of Go: Traps, Gotc ...
MongoDB学习笔记(入门)
MongoDB学习笔记(入门) 一.文档的注意事项: 1. 键值对是有序的,如:{ "name" : "stephen", "genda" ...

Pythton学习笔记1