03_python基础
运行第一个Python程序
print("Hello,World")
print()输出
- 作用:在控制台上打印信息；
- demo:
print("Hello，python，pleasure to meet you!")
可以接收多个字符串,用" , " 号隔开, 遇到"," 会输出一个空格；
输出:
print(8)
print(8 + 10)
print("8+10=",18)
字符串和数字可以直接输出,数值，布尔，列表，字典...都可以直接输出。
注释
单行注释:
# 这是单行注释
多行注释：
"""
这是多行注释1
"""
'''
这是多行注释2
'''
input()输入
- 作用：从外部获取值。
input函数在python中是一个内建函数，其从标准输入中读入一个字符串，并自动忽略换行符。也就是说所有形式的输入按字符串处理，如果想要得到其他类型的数据进行强制类型转化。默认情况下没有提示字符串（prompt string），在给定提示字符串下，会在读入标准输入前标准输出提示字符串。
-
demo:
info = input("请输入信息内容:")
运行Python程序的三种方式
- 1.终端中进入Python解释器环境
C:\Users\King>python
Python 3.6.5 |Anaconda, Inc.| (default, Mar 29 2018, 13:32:41) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello,World")
Hello,World
>>>
- 2.终端中运行Python脚本启动Python。（该种方法会调用相关的脚本解释器）
C:\Users\King>python hello.py # 进入脚本对应的路径
或者
C:\Users\King>python d:hello.py # 进入脚本对应的路径
- 3.在集成开发环境（IDE，Integrated Development Environment）中运行Python。
集成开发环境通常整合了文本编辑器、集成的调试器等工具，支持各种源代码控制工具。
# -*- coding: utf-8 -*-
# 或者
#coding:utf-8
Python常见数据类型
计算机顾明思议就是可以做数学运算的机器,因此计算机理所当然的可以处理各种数据,但是计算机能处理的远远不止数值,还有文本,图形,音频,视频网页等各种数据, 不同数据,需要定义不同的数据类型。Python中常见数据类型:
-
数字(number)
- 整型(int)
- 长整型(long)
- 浮点型(float)
- 复数(complex)
-
字符串(string)
-
布尔型(Bool)
-
列表(list)
-
元组(tuple)
-
集合(set)
-
字典(dict)
变量与常量
变量
概念：
-
程序可操作的存储区名称。
-
程序运行存储区中能改变的数据。
-
每个变量都有特定的类型。
-
作用: 将不同类型的数据存储到内存。
变量的定义:
变量名 = 初始值(为了确定变量类型)
"=" 表示赋值运算,把 "=" 右边的值赋值给左边的一个变量。
# num = 100
# 苹果的价钱, 元/kg
# apple_pric #下划线法 python希望用下划线法
applePrice = 9.98 # 驼峰法 老工程师用 从java转过来的
appleWeight = 2
total = applePric * appleWeight # 在Python当定义
totalq = total - 0.2 # 当total = 就是 赋值
print(totalq)
# 变量要先定义后使用，否则报错
# 删除变量
#
# 语法: del 变量名
del total
print(total)
变量命名
命名规则:
-
1.必须由字母,数字,下划线组成
-
2.不能以数字开头
-
3.不能是python中的关键字
-
4.见名知意
-
5.严格区分大小写
关键字查看
import keyword
print(keyword.kwlist)
查看变量类型
type(变量名)
查看变量内存地址
id(变量)
常量
常量即指不变的量，如pai 3.141592653..., 或在程序运行过程中不会改变的量。在Python中没有一个专门的语法代表常量，程序员约定俗成用变量名全部大写代表常量。
PI = 3.1415926
在c语言中有专门的常量定义语法，const int count = 60;一旦定义为常量，更改即会报错。
数据类型概述
什么是数据类型？
我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让它处理文字，就传字符串类型给它。
- 整数类型（int）。
int（整型）
在32位机器上，整数的位数为32位，取值范围为\(-2^{31}\)~\(2^{31} - 1\)，即-2147483648～2147483647;
在64位系统上，整数的位数为64位，取值范围为\(-2^{63}\)～\(2^{63}-1\)，即-9223372036854775808～9223372036854775807。
long（长整型）
跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
注意：在Python3里不再有long类型了，全都是int.
>>> a = 2 ** 2048
>>> type(a)
<class 'int'>
- 浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示；
- 复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
# 数字:Python张总可以表示任意长度的一个数字
# 类型: int float
num1 = 100
# 定义多个变量
# num1, num2, num3 = 100 #不可以
"""
num1 = num2 = num3 = 100
print(num1)
print(num2)
print(num3)
"""
#交换值 num4=100 num5 = 80
num4 = 80
num5 = 100
num4, num5 = 100, 80.2
# temp = num4
# num4 = num5
# num5 = temp
# print(type(num4))
# print(type(num5))
# 浮点型float (有整数部分和小数部分)
#强转 不能将非数字字符的在字符串转化成数字
# f1 = int("a1")
# f2 = 2.2
# print(type(f1 + f2))
# print(type(f1))
# print(type(f2))
# 把浮点型强转为整型的时候,会将小数位舍去
f3 = 3.688
f4 = int(f3)
print(f4)
# 会默认保留一位小数
f5 = 20
f6 = float(f5)
print(type(f5))
print(f6)
- 布尔值
布尔类型很简单，就两个值 ，一个True(真)，一个False(假), 主要用记逻辑判断
但其实你们并不明白对么？ let me explain, 我现在有2个值 ， a=3, b=5 , 我说a>b你说成立么? 我们当然知道不成立，但问题是计算机怎么去描述这成不成立呢？或者说a< b是成立，计算机怎么描述这是成立呢？
没错，答案就是，用布尔类型。
>>> a=3
>>> b=5
>>>
>>> a > b #不成立就是False,即假
False
>>>
>>> a < b #成立就是True, 即真
True
数据类型的强制转换
| No. | 强转类型 | 描述 |
|---|---|---|
| 1 | int(x [,base]) | 将x转换为整数。如果x是字符串，则要base指定基数。 |
| 2 | float(x) | 将x转换为浮点数。 |
| 3 | complex(real [,imag]) | 创建一个复数。 |
| 4 | str(x) | 将对象x转换为字符串表示形式。 |
| 5 | repr(x) | 将对象x转换为表达式字符串。 |
| 6 | eval(str) | 评估求值一个字符串并返回一个对象。 |
| 7 | tuple(s) | 将s转换为元组。 |
| 8 | list(s) | 将s转换为列表。 |
| 9 | set(s) | 将s转换为集合。 |
| 10 | dict(d) | 创建一个字典，d必须是(key，value)元组的序列 |
| 11 | frozenset(s) | 将s转换为冻结集 |
| 12 | chr(x) | 将整数x转换为字符 |
| 13 | unichr(x) | 将整数x转换为Unicode字符。 |
| 14 | ord(x) | 将单个字符x转换为其整数值。 |
| 15 | bin(x) | 将整数x转换为二进制字符串。 |
| 16 | hex(x) | 将整数x转换为十六进制字符串。 |
| 17 | oct(x) | 将整数x转换为八进制字符串。 |
常见数学函数
| 函数名 | 描述 |
|---|---|
| abs(x) | 返回数字的绝对值，如abs(-10) 返回 10 |
| pow(x, y) | \(x^y\) 运算后的值。 |
| round(x [,n]) | 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。 |
| math.exp(x) | 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 |
| math.fabs(x) | 返回数字的绝对值，如math.fabs(-10) 返回10.0 |
| math.ceil(x) | 返回数字的上入整数，如math.ceil(4.1) 返回 5 |
| math.floor(x) | 返回数字的下舍整数，如math.floor(4.9)返回 4 |
| math.log(x) | 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
| math.log10(x) | 返回以10为基数的x的对数，如math.log10(100)返回 2.0 |
| math.modf(x) | 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 |
| math.sqrt(x) | 返回数字x的平方根 |
| max(x1, x2,...) | 返回给定参数的最大值，参数可以为序列。 |
| min(x1, x2,...) | 返回给定参数的最小值，参数可以为序列。 |
表达式与运算符
- 表达式
由变量,常量和运算符组成的式子称为表达式。
- 运算符
计算机可以进行的运算有很多种，可不只加减乘除这么简单，运算按种类可分为算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算。
Python算术运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 : 两个对象相加 | a + b |
| - | 减 :得到负数或是一个数减去另一个数 | a - b |
| * | 乘 : 两个数相乘或是返回一个被重复若干次的字符串 | a * b |
| / | 除 : x 除以 y | b / a |
| ** | 幂 : 返回x的y次幂 | a**b |
| % | 取模 : 返回除法的余数 | b % a |
| // | 取整除 : 向下取接近除数的整数 | a//b |
拓展：
divmod(x, y)>>> divmod(23, 4) (5, 3)
a = 6
b = 12
c = 0
c = a + b
print ("1: c 的值为：", c)
c = a - b
print ("2: c 的值为：", c)
c = a * b
print ("3: c 的值为：", c)
c = a / b
print ("4: c 的值为：", c)
c = a % b
print ("5 - c 的值为：", c)
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b
print ("6 - c 的值为：", c)
a = 10
b = 5
c = a//b
print ("7 - c 的值为：", c)
Python比较运算符
以下假设变量a为10，变量b为20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 True。 |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
| < | 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 | (a < b) 返回 True。 |
| >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
| <= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 True。 |
Python赋值运算符
以下假设变量a为10，变量b为20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | 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 |
Python位运算符
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：
| 运算符 | 描述 |
|---|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 |
| | | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 |
| >> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 |
下表中变量 a 为 31，b 为 15二进制格式如下：
a = 0001 1111
b = 0000 1111
----------------
a&b = 0000 1111
a|b = 0001 1111
a^b = 0001 0000
~a = 1110 0000
a<<2 = 0111 1100
a>>2 = 0000 0111
>>> a = 31
>>> b = 15
>>> a & b
15
>>> a | b
31
>>> a ^ b
16
>>> ~a
-32
>>> a << 2
124
>>> a >> 2
7
Python逻辑运算符
Python语言支持逻辑运算符，
| 运算符 | 逻辑表达式 | 描述 |
|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 |
| or | x or y | 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 |
同样仍以变量 a 为 31，b 为 15为例：
>>> a and b
15
>>> a or b
31
>>> not a
False
针对逻辑运算的进一步研究：
1,在没有()的情况下not 优先级高于 and，and优先级高于or，即优先级关系为( )>not>and>or，同一优先级从左往右计算。
判断逻辑语句的正与负：
3>4 or 4<3 and 1==1 #
1 < 2 and 3 < 4 or 1>2 #
2 > 1 and 3 < 4 or 4 > 5 and 2 < 1 #
1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8 #
1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 > 8 #
1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6 #
not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6#
3>4 or 4<3 and 1==1 #F
1 < 2 and 3 < 4 or 1>2 #T
2 > 1 and 3 < 4 or 4 > 5 and 2 < 1 #T
1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8 #F
1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 > 8 #T
1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6 #F
not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6#F
Python成员运算符
除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
Python身份运算符
身份运算符用于比较两个对象的存储单元
| 运算符 | 描述 | 实例 |
|---|---|---|
| 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。 |
注： id() 函数用于获取对象内存地址。
Python运算符优先级
以下表格列出了从最高到最低优先级的所有运算符：
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 'AND' |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not and or | 逻辑运算符 |
随机函数
导入一个模块
import random
random模块的功能:
1.random.random()
用于生成一个0到1的随机浮点数：0<= n < 1.0
import random
a = random.random()
print(a)
2.random.uniform(a,b)
用于生成一个指定范围内的随机浮点数，两个参数其中一个是上限，一个是下限。如果a > b，则生成的随机数n: a <= n <= b。如果 a <b， 则 b <= n <= a。
import random
print(random.uniform(1,10))
print(random.uniform(10,1))
3.random.randint(a, b)
用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b
import random
print(random.randint(1,10))
4.random.randrange([start], stop[, step])
从指定范围内，按指定基数递增的集合中 获取一个随机数。
random.randrange(10, 30, 2)，结果相当于从[10, 12, 14, 16, ... 26, 28]序列中获取一个随机数。
random.randrange(10, 30, 2)在结果上与 random.choice(range(10, 30, 2) 等效。
import random
print(random.randrange(10,30,2))
5.random.choice(sequence)
random.choice从序列中获取一个随机元素。其函数原型为：random.choice(sequence)。
参数sequence表示一个有序类型。这里要说明 一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。list, tuple, 字符串都属于sequence。
import random
lst = ['python','C','C++','javascript']
str1 = ('I love python')
print(random.choice(lst))
print(random.choice(str1))
6.random.shuffle(x[, random])
用于将一个列表中的元素打乱,即将列表内的元素随机排列。
import random
p = ['A' , 'B', 'C', 'D', 'E' ]
random.shuffle(p)
print (p)
7.random.sample(sequence, k)
从指定序列中随机获取指定长度的片断并随机排列。注意：sample函数不会修改原有序列。
import random
lst = [1,2,3,4,5]
print(random.sample(lst,4))
print(lst)
格式化输出
现有一练习需求，问用户的姓名、年龄、工作、爱好 ，然后打印成以下格式。
Name:Linus
Age:18
Job:IT
Hobbie:Read
---info of Linus---
Name : Linus
Age : 18
job : IT
Hobbie: Read
-------end------
你怎么实现呢？你会发现，用字符拼接的方式还难实现这种格式的输出，所以一起来学一下新姿势
只需要把要打印的格式先准备好， 由于里面的 一些信息是需要用户输入的，你没办法预设知道，因此可以先放置个占位符，再把字符串里的占位符与外部的变量做个映射关系就好啦。
在编写程序的过程中，经常需要进行格式化输出，每次用每次查。干脆就在这里整理一下，以便索引。
格式化操作符（%）
"%"是Python风格的字符串格式化操作符，非常类似C语言里的printf()函数的字符串格式化（C语言中也是使用%）。
下面整理了一下Python中字符串格式化符号：
| 格式化符号 | 说明 |
|---|---|
| %c | 转换成字符（ASCII 码值，或者长度为一的字符串） |
| %r | 优先用repr()函数进行字符串转换 |
| %s | 优先用str()函数进行字符串转换 |
| %d / %i | 转成有符号十进制数 |
| %u | 转成无符号十进制数 |
| %o | 转成无符号八进制数 |
| %x / %X | 转成无符号十六进制数（x / X 代表转换后的十六进制字符的大小写） |
| %e / %E | 转成科学计数法（e / E控制输出e / E） |
| %f / %F | 转成浮点数（小数部分自然截断） |
| %g / %G | %e和%f / %E和%F 的简写 |
| %% | 输出% （格式化字符串里面包括百分号，那么必须使用%%） |
这里列出的格式化符合都比较简单，唯一想要强调一下的就是"%s"和"%r"的差别。
看个简单的代码：
>>> a = 15
>>> print(("%d to hex is %X") % (a, a))
15 to hex is F
>>> "%x" % 15
'f'
>>> "%f" % 15
'15.000000'
>>> "%e" % 15000
'1.500000e+04'
>>> "%d" % 100
'100'
>>> "%d%%" % 100
'100%'
name = input("Name:")
age = input("Age:")
job = input("Job:")
hobbie = input("Hobbie:")
info = '''
---info of %s---
Name :\t %s
Age :\t %s
job :\t %s
Hobbie:\t %s
-------end------
''' % (name, name, age,job,hobbie) # 这行的%号就是把前面的字符串与括号后面的变量关联起来
print(info)
%s就是代表字符串占位符，除此之外，还有%d,是数字占位符， 如果把上面的age后面的换成%d，就代表你必须只能输入数字啦,假如我们更改
Age :\t %s
为：
Age :\t %d
我们运行一下，输入相应内容，然后，我们发现报错：
Name:Linus
Age:18
Job:IT
Hobbie:Read
Traceback (most recent call last):
File "demo.py", line 13, in <module>
''' % (name, name, age,job,hobbie) # 这行的%号就是把前面的字符串与括号后面的变量关联起来
TypeError: %d format: a number is required, not str
说%d需要一个数字，而不是str, 纳尼? 我们明明输入的是数字呀，22，22呀。
不用担心 ，不要相信你的眼睛我们调试一下，看看输入的到底是不是数字呢？怎么看呢？查看数据类型的方法是什么来着？type()
name = input("Name:")
age = input("Age:")
print(type(age))
运行：
Name:Linus
Age:18
<class 'str'>
肯定没问题了。相反，能不能把字符串转成数字呢?当然可以啦，str( yourStr )。
问题：现在有这么行代码：
info = "I'm %s,my age is %d,目前Python学习进度为5%“ % (Linus, 18)
print(info)
运行发现报错如下：
Traceback (most recent call last):
File "C:\Users\King\Desktop\小猪佩奇\demo.py", line 1, in <module>
info = "I'm %s,my age is %d,目前Python学习进度为5%" % ("Linus", 18)
ValueError: incomplete format
因为在格式化输出里，你出现%默认为就是占位符的%，但是我想在上面一条语句中最后的5%就是表示5%而不是占位符，怎么办？
info = "I'm %s,my age is %d,目前Python学习进度为5%%" % ("Linus", 18)
print(info)
这样就可以了，第一个%是对第二个%的转译，告诉Python解释器这只是一个单纯的%，而不是占位符。
总结：
格式化输出：
%占位符，s，字符串，d digit数字8%
%%只是单纯的显示%
格式符
格式符为真实值预留位置，并控制显示的格式。格式符可以包含有一个类型码，用以控制显示的类型，如下:
%s 字符串 (采用str()的显示)
%r 字符串 (采用repr()的显示)
%c 单个字符
%b 二进制整数
%d 十进制整数
%i 十进制整数
%o 八进制整数
%x 十六进制整数
%e 指数 (基底写为e)
%E 指数 (基底写为E)
%f 浮点数
%F 浮点数，与上相同
%g 指数(e)或浮点数 (根据显示长度)
%G 指数(E)或浮点数 (根据显示长度)
%% 字符"%"
可以用如下的方式，对格式进行进一步的控制：
%[(name)][flags][width].[precision]typecode
(name)为命名
flags可以有+,-,' '或0。
+表示右对齐。
-表示左对齐。
' '为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。
0表示使用0填充。
width表示显示宽度
precision表示小数点后精度
比如：
print("%+10x" % 10)
print("%04d" % 5)
print("%6.3f" % 2.3)
上面的width, precision为两个整数。我们可以利用*，来动态代入这两个量。比如：
print("%.*f" % (4, 1.2))
Python实际上用4来替换*。所以实际的模板为"%.4f"。
Python中内置的%操作符可用于格式化字符串操作，控制字符串的呈现格式。Python中还有其他的格式化字符串的方式，但%操作符的使用是最方便的。
另外python还有一个更强大的字符串处理函数 str.format()
format格式化
它通过{}和:来代替%。
“映射”示例
通过位置
字符串的format函数可以接受不限个参数，位置可以不按顺序，可以不用或者用多次，不过2.6不能为空{}，2.7才可以。
通过关键字参数
通过对象属性
通过下标
有了这些便捷的“映射”方式，我们就有了偷懒利器。基本的python知识告诉我们，list和tuple可以通过“打散”成普通参数给函数，而dict可以打散成关键字参数给函数（通过和*）。所以可以轻松的传个list/tuple/dict给format函数。非常灵活。
格式限定符
它有着丰富的的“格式限定符”（语法是{}中带:号），比如：
填充与对齐填充常跟对齐一起使用
^、<、>分别是居中、左对齐、右对齐，后面带宽度
:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
比如
精度与类型f精度常跟类型f一起使用
其中.2表示长度为2的精度，f表示float类型。
其他类型主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制。
用，号还能用来做金额的千位分隔符。
基础数据类型的总结
按存储空间的占用分（从低到高）
数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改
按存值个数区分
| 标量／原子类型 | 数字，字符串 |
|---|---|
| 容器类型 | 列表，元组，字典 |
按可变不可变区分
| 可变 | 列表，字典 |
|---|---|
| 不可变 | 数字，字符串，元组，布尔值 |
按访问顺序区分
| 直接访问 | 数字 |
|---|---|
| 顺序访问（序列类型） | 字符串，列表，元组 |
| key值访问（映射类型） | 字典 |
浙公网安备 33010602011771号