零基础小白的Python学习之路（二）对象、变量、简单数据类型及运算符

参考资料：《Python编程 从入门到实战》+ 尚学堂Python400集

对象

在我们的这个Python语言中，同样存在对象这个概念，在C++中，对象是类的实例化出得具体实例，里面封装了类的属性成员，方法等，而在Python中也比较相似。
在Python中，对象的本质是一个内存块，里面同样有一些属性值，一些类型等。
如图，在内存中，每个对象大致是这样的情况
包含：

• 标识（唯一）（identity）
• 类型（type）
• 值（value）
  多个不同大小的对象（内存块）位于计算机的堆空间当中
  
  我们可以通过这几个函数找到对应的值：

a = 3
print(id(a))
print(type(a))
print(a)

输出结果：

此时内存当中是这样的：

实际上，id就是我们的对象的地址，在新定义一个变量a时，其实是将这个对象中的id（即地址）赋值给我们的变量a，我们在访问3这个值的时候是通过变量a所被赋的id值找到这个对象中的value值的。
于是我们“引用”的概念如下：

引用

在 Python 中，变量也成为：对象的引用。
因为，变量存储的就是对象的地址。
变量通过地址引用了“对象”。
变量位于：栈内存
对象位于：堆内存。

变量

1、变量声明

基本格式： 变量名 = 表达式
【注】

• 和C / C++ 等语言等不同，Python是动态类型语言，变量不需显式声明类型，根据变量所引用的对象，Python解释器自动确定数据类型。
• 使用前必须初始化。
• Python是强类型语言，每个对象都有数据类型，只支持该类型支持的操作。
• 对象和变量：

del a

表示删除栈中的a变量（但对象仍然存在）
如果最终对象没有被变量引用，就会被垃圾回收

2、链式赋值

x = y = z = 3

3、系列解包赋值及变量互换

a,b,c = 4,5,6
a,b = 1,2
a,b = b,a

4、常量问题

Python中不支持常量，只能在逻辑上进行实现

基本内置数据类型

• 整型
• 浮点型
• 布尔型
• 字符串

整型（数字）

基本运算符

• 加：+
• 减：-
• 乘：*
• 除：
  -浮点数除法：/
  -整数除法：//
• 模（取余）：%
• 幂：**

【注】余数不能为0，会抛异常
另：divmod()函数可以同时得到商和余数（返回的是一个元组）

a = 13
b = 3
c = divmod(a,b)
print(c)

整数

在Python中，除十进制外，还有二进制、八进制和十六进制
Python3中，int可存储任意大小的整数，那些巨大的科学计算就可以利用Python来实现了

• 二进制：0b / 0B，0 1
• 八进制：0o / 0O，0 1 2 3 4 5 6 7
• 十六进制：0x / 0X，0 1 2 3 4 5 6 7 8 9 a b c d e f

>>> 0b101
5
>>> 0o10
8
>>> 0x10
16
>>> 0xff
255

转换函数：

• bin()：转成二进制
• oct()：转成八进制
• hex()：转成十六进制

n = input("输入十进制数：")
num = int(n)
print("转换为二进制数为：", bin(num))
print("转换为八进制数为：", oct(num))
print("转换为十六进制数为：", hex(num))

整数与其他数据类型的转换

使用int()函数实现类型转换

• 浮点数：Python中直接舍去小数部分（注意不会四舍五入！）
• 布尔值：True—>1；False—>0
• 符合整数格式的字符串：浮点数会报错，不支持，整数直接转换成对应整数

a = 65.79
print(int(a))
b = True
print(int(b))
c = "125"
print(int(c))

浮点型

表示

浮点数（float）用$$a\times b^{10}$$形式的科学计数法表示。比如：3.14，表示成：314E-2 或者 314e-2。 这些数字在内存中也是按照科学计数法存储。

类型转换

• 类似于int()函数，float()函数用来转换成浮点数
• 整数+浮点数的混合运算，表达式结果会自动转成浮点数
• round()函数：可以返回浮点数四舍五入后的值
  【注】不会改变原有值，而是产生新的值，并返回

a = 314E-2
print(float(a))
b = "91.75"
print(float(b))
print(round(float(b)))

c = 123
d = 75.4
print(type(c))
print(type(d))
f = c + d
print(f)
print(type(f))

增强型赋值运算符

• +=
• -=
• *=
• /=
• //=
• **=
• %=

补充一个小点

关于时间表示
Unix时间点，也叫Unix时间戳
时间戳是自 1970 年 1 月 1 日（00:00:00 GMT）以来的秒数。它也被称为 Unix 时间戳（Unix Timestamp）。

Unix时间戳(Unix timestamp)，或称Unix时间(Unix time)、POSIX时间(POSIX time)，是一种时间表示方式，定义为从格林威治时间1970年01月01日00时00分00秒起至现在的总秒数（以毫秒计算）。Unix时间戳不仅被使用在Unix系统、类Unix系统中，也在许多其他操作系统中被广泛采用。
比如在Python中

import time
t_second = int(time.time())
t_minute = t_second//60
t_hour = t_minute//60
t_day = t_hour//24
t_year = t_day//365
print(t_year)
print("今年是"+str(1970 + t_year)+"年")

其他基本运算符

运算符	说明
and , or , not	布尔与 ，布尔或，布尔非
is , is not	同一性判断，判断是否为同一个对象
＜,＜＝,＞,＞＝ ,!= , ==	比较值，可以连用
<< , >>	移位（左移1位相当于乘以2，右移1位相当于除以2）
~	按位翻转
+ , - , * , / , // , %	加，减，乘，浮点除，整数除，取余
**	幂运算

布尔型

两个关键字：True 和 False
True = 1
False = 0
所以也可以和整数进行运算

a = True
b = 5
print(a+b)

比较运算符

• ==
• !=
• ＞
• ＜
• ＞=
• ＜=

逻辑运算符

• 或 or：x or y：
  -若x为True—>True
  -若x为False—>y的值
• 与 and：x and y：
  -若x为True—>y的值
  -若x为False—>False
• 非 not：not x：
  -若x为True—>False
  -若x为False—>True

运算符优先级

【注】

• 乘除优先于加减
• 位运算和算术运算>比较运算符>赋值运算符>逻辑运算符

字符串

本质：字符序列

• Python字符串不可变（不可以直接替换其中某一字符）
• Python不支持单字符类型，也作为一个字符串来使用

字符串的包括

• 单引号 / 双引号（根据具体情况，比如用于区别于句子间的引号等情况）
• 三个单引号 / 三个双引号（创建多行字符串）
• 字符串可以为空：str = “”（中间无空格）

n = '''
	She saids:"Are you kidding me?"
	and he answered:"No, I'm serious!"
	'''
print(n)

字符串编码

Python：Unicode（16位）
两个配对内置函数：

• ord()：将字符转换成对应的ASCII 数值 / Unicode 数值
• chr()：将十进制数字转换成对应字符

a = "b"
print(ord(a))
m = 97
print(chr(m))

求字符串长度

• len()

字符串大小写转换

• capitalize()：整个字符串只令第一个字母变为大写
• title()：字符串当中的每个单词首字母转成大写
• upper()：所有字符全转成大写
• lower()：所有字符全转成小写
• swapcase()：所有字母大小写替换

字符串拼接

• 加号“+”拼接：
  - “+”号两边为字符串—>直接拼接
  - “+”号两边为数字—>进行加法运算
  - “+”号两边类型不同—>抛异常
• 多个字符串放到一起直接拼接：
  -如，‘aa’ ‘bb’ ——> ‘aabb’

字符串复制

a = 'asd' * 3
print(a)

不换行打印字符串

基本格式：print(“字符串1” , end = “字符串2”)

• 字符串1：要打印的字符串
• 字符串2：以什么样的字符串结尾（可以是任意或空格或空，默认是换行符）

print("abc" , end = "")
print("def" , end = "")
print("ghi")

从控制台读取字符串（键盘输入）

• input()：从控制台读取键盘输入内容

>>> my = input("请输入你的名字:")
请输入你的名字:黎明
>>> my
'黎明'
>>> 

str()函数：数字—>字符串

a = 3.1415
b = str(a)
print(a)
print(type(a))
print(b)
print(type(b))

会发现，虽然输出的值是一样的，但数据类型已经由浮点型float转变成了字符串类型str
同样，布尔值和科学计数法也可以进行转换：

a = 3.14e3
b = True
print(type(a))
print(type(b))
print(str(a))
print(type(str(a)))
print(str(b))
print(type(str(b)))

使用[ ]提取字符

基本格式：变量名[偏移量]
类似C中的数组按下标访问
偏移量可以正向（从左至右），也可以反向（从右至左）

• 正向搜索：0 , 1 , 2 , … , len(str)-1
• 反向搜索：-len(str) , … , -3 , -2 , -1

a = "abcdefghijklmn"
b = len(a)
print(b)
print(a[0])
print(a[b-1])
print(a[-1])
print(a[-b])

字符串替换

• replace()：将字符串中某一位置的字符串替换
  【注】本质：创建新的字符串对象作为原来的替换

a = "abcdefghijklmn"
a = a.replace('c' , '肖')
print(a)

字符串切片（slice操作）

快速提取字符串
基本格式：变量名[start : end : step]
【注1】若超出范围，则按照原最大范围进行提取
【注2】start 和 end，包头不包尾

• start：起始偏移量，可为空，默认从头开始
• end：终止偏移量，可为空，默认到结尾
• step：步长，可为空，默认步长为1

a = "abcdefghijklmn"
# 正数
# 提取整个字符串
print(a[:])
# 提取（下标）1 到 5-1=4 的字符串，默认步长为1
print(a[1:5])
# 从 start=2 开始到结尾的字符串
print(a[2:])
# 从头开始到 end-1=7-1=6 的字符串
print(a[:7])
# 从 start=1 提取到 end-1=8-1=7，步长step=2 的字符串
print(a[1:8:2])
print("\n")

# 负数
# 从倒数第3个开始到结尾
print(a[-3:])
# 从倒数第8个到倒数第-3-1个
print(a[-8:-3])
# step=-1，反向提取，相当于将字符串逆序排列
print(a[::-1])

split()分割 和 join()合并

• split()：将字符串分割成多个子字符串（存储到列表中）
  -split()：默认按空格分隔（或其他空白字符：换行符/空格/制表符）
  -split(‘字符串’)：按字符串分割（分割后该字符串不在列表中）

a = "a b c d e f"
a = a.split()
print(a)

b = "to be or not to be a man"
b = b.split("be")
print(b)

• join()：将一系列子字符串连接起来
  基本格式：“字符串”.join(变量名)

a = ['hello','my','name','is','Jason']
b = "*".join(a)
c = "".join(a)
d = "\n".join(a)
print(b)
print(c)
print(d)

【注】字符串拼接符“+” VS join()函数
使用字符串拼接符+，会生成新的字符串对象，因此不推荐使用+来拼接字符串。推荐 使用 join 函数，因为 join 函数在拼接字符串之前会计算所有字符串的长度，然后逐一拷贝， 仅新建一次对象。

字符串驻留机制和字符串比较

仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。 Python 支持字符串驻留机制，对于符合标识符规则的字符串（仅包含下划线（_）、字母 和数字）会启用字符串驻留机制驻留机制。

>>> a = "dd#"
>>> b = "dd#"
>>> a is b
False
>>> a == b
True
>>> str1 = "aa"
>>> str2 = "bb"
>>> str1+str2 is "aabb"
False
>>> str1+str2 == "aabb"
True
>>> c = "add_2"
>>> d = "add_2"
>>> c is d
True
>>> c == d
True
>>> 

字符串比较和同一性

注意区别 == / != 和 is / not is

• == / != 比较的是字符串的值，也就是对象中的value属性，是否含有相同字符
• is / not is 比较的是对象的地址，比较两个对象是否是同一个对象

成员操作符

• in / not in：判断某个字符（子字符串）是否存在于字符串中

转义字符总结

基本：\ + 特殊字符

• \（行尾）：续行符
• \\：单反斜杠
• \’：单引号
• \"：双引号
• \b：退格（Backspace）
• \t：横向制表符
• \r：回车
• \n：换行

字符串其他常用方法

（1）常用查找方法：

• 变量名.startswith(“字符串”)：是否以该字符串为开始（返回布尔值）
• 变量名.endswith(“字符串”)：是否以该字符串为结束（返回布尔值）
• 变量名.find(“字符串”)：该字符串第一次出现的位置下标
• 变量名.rfind(“字符串”)：该字符串最后一次出现的位置下标
• 变量名.count(“字符串”)：指定字符串共出现了几次
• 变量名.isalnum(“字符串”)：所有字符是否全是字母或数字（返回布尔值）

（2）去除首尾信息、删除空白

• 变量名.strip(“字符串”)：去除首尾的指定字符串信息，可以为空，默认为空白符
• 变量名.lstrip(“字符串”)：去除首部（左侧）的指定字符串信息，可以为空，默认为空白符——>类比左对齐
• 变量名.rstrip(“字符串”)：去除尾部（右侧）的指定字符串信息，可以为空，默认为空白符——>类比右对齐

（3）格式排版

• 变量名.center(整个版面长度,“填充字符”)：居中，默认空白符
• 变量名.ljust(整个版面长度,“填充字符”)：左对齐，默认空白符
• 变量名.rjust(整个版面长度,“填充字符”)：右对齐，默认空白符

a = "fgdigdh"
print(a.center(13,"*"))
print(a.ljust(11,"#"))
print(a.rjust(16,"@"))

（4）其他字符串检测函数

• isalnum()：是否为字母或数字
• isalpha()：检测字符串是否只由字母组成(含汉字)
• isdigit()：检测字符串是否只由数字组成
• isspace()：检测是否为空白符
• isupper()：是否为大写字母
• islower()：是否为小写字母

字符串的格式化

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的 功能。
format 函数可以接受不限个参数，位置可以不按顺序。

基本格式1（索引）：
变量名 = “属性一是：{0} , 属性二是：{1}”
变量名.format(属性一值，属性二值)

基本格式2（参数名）：
变量名 = “属性一是：{属性一变量名。} , 属性二是：{属性二变量名}”
变量名.format(属性一变量名 = 属性一值，属性二变量名 = 属性二值)

a = "名字是:{0},年龄是:{1},{0}很优秀"
print(a.format("Jason",24))

a = "名字是:{name},年龄是:{age},{name}很优秀"
print(a.format(age = 24,name = "Jason"))

填充与对齐

• ^：居中
• <：左对齐
• ＞：右对齐

a = "{:*>8}".format("233")
print(a)
b = "我是{name},我喜欢{num:*^8}".format(num = 666,name = "Jason")
print(b)

数字格式化

a = "我今年{age}岁了，出生于{year}年，平均学分绩点{gpa:.1f}，\n\
    今天的温度为{tem:+.2f}摄氏度，路上买菜{price:.0f}元1斤，\n\
    又想起曾经在跑道上穿着{num:0>2d}号的球服在场上奔跑，\n\
    拿到了{salary:4<4d}元的工资，五年后，我拿到了{pay:,}的支票，\n\
    后来我拿出{percent:.2%}的积蓄投身公益事业，充实有意义"
print(a.format(age = 24 , year = 1996 , gpa = 3.15 , tem = -15.65 , price = 2.99 ,
               num = 5 , salary = 6 , pay = 1800000 , percent = 0.75))

可变字符串

在 Python 中，字符串属于不可变对象，不支持原地修改，如果需要修改其中的值，只能创建新的字符串对象。但是，有时我们需要原地修改字符串，可以使用 io.StringIO 对象或 array 模块。

import io
a = "welcome to ASD"
a_io = io.StringIO(a)
print(a_io)
print(a_io.getvalue())
a_io.seek(11)
a_io.write("P")
print(a_io.getvalue())