Python基础系列（二）基础概念，进入python的第一课！（基本类型认知、互转）

首先，非常感谢各位打开本博文，本博文是Python入门基础系列文章之一，Python目前是非常火的编程工具。其实作为编程不在只是程序员的专利，每一个人在日常的工作中、学习中都会或多或少的要用到一些工具去帮助我们解决问题，那么，Python将会是一个非常合适的工具之一。
笔者认为，python已经类似office一样，成为了我们日常办公中的重要工具。作为Python入门基础系列文章，共包含六篇，具体文章如下：

1. 好的开始，是成功的起点。（python+pycharm+print+pip+快捷键）
2. 基础概念，进入python的第一课！（基本类型认知、互转）
3. 文件操作，让python与外界互联互通！（os）
4. 多线程处理，python的一把利器！（thread）
5. 类和对象，让你更懂你的python代码！（class）
6. Debug代码跟踪和try-except异常捕获，排错的万能助手！（DEBUG）
7. python中常用的pip库介绍

千里之行，始于足下，让我们一起在python的世界里分享、学习、共同进步吧！好的，下面让我们正式进入本章：基础概念，进入python的第一课！（基本类型认知、互转）

一、基本概念：

（一） 标识符

标识符是编程时使用的名字，用于给变量、函数、语句块等命名，Python 中标识符由字母、数字、下划线组成，不能以数字开头，区分大小写。
Python 中的关键字（保留字），我们在自定义标识符时不能使用关键字。

n = 200  #数值型
str = '你好，python！' #字符型
li =['a','b','c','d'] # list类型
tuple1 = (1,2,3)  #tuple元组
print(n)
print(str)
print(li)
print(tuple1)

运行结果如下：

200
你好，python！
['a', 'b', 'c', 'd']
(1, 2, 3)

（二）、编码

Python2 中默认编码为 ASCII，假如内容为汉字，不指定编码便不能正确的输出及读取，比如我们想要指定编码为 UTF-8，Python 中通过在开头加入 # -- coding: UTF-8 -- 进行指定。
Python3 中默认编码为 UTF-8，因此在使用 Python3 时，我们通常不需指定编码。

 # -*- coding: UTF-8 -*- 

（三）、注释

Python 中单行注释使用 #，多行注释使用三个单引号（’’’）或三个双引号（"""）。

（四）、常用运算符

运算符	描述	示例
%	取模	a % b
**	幂	a**b 表示 a 的 b 次幂
//	取整除	9 // 4 结果为 2
==	是否相等	a == b
!=	是否不等于	a != b
&	与	a & b
	或	a
^	异或	a ^ b
~	取反	~a
and	布尔类型与	a and b
or	布尔类型或	a or b
not	布尔类型非	not a
is	判断两个标识符是否引用同一个对象	a is b
is not	判断两个标识符是否引用不同对象	a is not b

二、python的数据类型

python不需要事先声明数据类型，当python运行时，会根据“=“右侧的数据类型来确定变量类型。

（一）、基本数据类型

1、数值型：包括Integer整型、Boolean布尔型、Floating浮点型等
2、String字符串：以单引号 ‘、双引号"、三引号> ‘’’ 或 “”"括起来的文本
3、List 列表、Tuple 元组、Dictionary 字典
4、其他内建类型：空值（用 None> 表示）、变量（可变）、常量（不可变）

（二）、基本对象类型分类

有3种不同的模型可以帮助我们对基本类型进行分类
1）存储类型

一个能保存单个对象的类型，称为原子或标量存储；可以容纳多个对象的类型，称为容器存储；并且所有的python容器对象都可以容纳不同类型的对象；
注意，python没有字符类型，所以虽然字符串你看上去像容器类型，实际是原子类型
2）更新模型（是否可变）

这里所说的是否可变，可更新是针对的对象的值而言的；是在对象身份不变的情况下（id不变），值是否可更新；
3）访问模型

序列是指容器内的元素按从0开始的索引顺序访问；

字典的元素是一个一个的键值对，类似于哈希表；通过获取键，对键执行一个哈希操作，根据计算的结果，选择在数据结构的某个地址中存储你的值。任何一个值的存储地址取决于它的键；所以字典是无序的，键必须是不可变类型（对于元祖，只能是元素不可变的元祖）

4）分类小结：

（三）常见数据类型详解

1、数值类型

（1）常见数值类型

分别是：整型（int）、浮点型（float）等，如果你使用的还是我的低版本 Python2，那么还包含长整型（long）。其中：浮点型：由整数部分和小数部分组成。

种类	描述	引导符
二进制	由 0 和 1 组成	0b 或 0B
八进制	由 0 到 7 组成	0o 或 0O
十进制	默认情况	无
十六进制	由 0 到 9、a 到 f、A 到 F 组成，不区分大小写	0x 或 0X

（2）常见的基本运算

常见的基本运算包括如下：

运算	描述
x // y	x 除以 y，取整除
x % y	x 除以 y，取模
-x	x 取反
+x	x 不变
abs(x)	x 的绝对值
int(x)	将 x 转换为整数
float(x)	将 x 转换为浮点数
complex(x, y)	一个带有实部 x 和虚部 y 的复数，y 默认为 0。
divmod(x, y)	(x // y, x % y)
pow(x, y)	x 的 y 次幂
x ** y	x 的 y 次幂

（3）常见的数学函数

除了上面的基本运算外，我还可以借助数学模块 math和random 实现更多的数学函数运算（需要先引入数学模块math和random）。

函数	描述
math.sqrt(x)	返回平方根
math.abs(x)	返回 x 的绝对值
math.ceil(x)	返回 x 的上入整数，如：math.ceil(1.1) 返回 2
math.floor(x)	返回 x 的下舍整数，如：math.floor(1.1) 返回 1
math.exp(x)	返回 e 的 x 次幂
math.log(x)	返回以 e 为底 x 的对数
math.log10(x)	返回以 10 为底 x 的对数
math.pow(x, y)	返回 x 的 y 次幂
math.sqrt(x)	返回 x 的平方根
math.factorial(x)	返回 x 的阶乘
random.random(x)	随机生成一个 0 到 1 范围内的实数。
random.uniform(x, y)	随机生成一个 x 到 y 范围内的实数。

2、字符类型

字符串是 Python 的一种数据类型，它可以通过单引号 ‘、双引号 "、三引号 ‘’’ 或 “”" 来定义。

（1）获取数据：

s = 'Python'
访问第一个字符 P
print(s[0])
访问范围内字符
print(s[1:3])
print(s[:3])
print(s[3:])  

（2）获取字符编码

Python使用了ord()函数返回单个字符的编码，chr()函数把编码转成相应字符。

s = 'A'
print(ord(s))
print(chr(65))

（3）特殊字符

常见的转义字符如下表所示：

转义字符	描述
\	在行尾使用时，用作续行符
\b	退格（Backspace）
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车

常见的字符串运算符：

运算符	描述
+	连接符
*	重复输出
[]	通过索引获取字符串中字符
[ : ]	获取字符串中的一部分
in	字符串中是否包含指定字符
not in	字符串中是否不包含指定字符
r	字符串原样输出

使用示例如下所示：

s1 = 'hello'
s2 = 'python'
print('s1 + s2 -->', s1 + s2)
print('s1 * 2 -->', s1 * 2)
print('s1[0] -->', s1[0])
print('s1[0:2] -->',s1[0:2])
print('"H" in s1 -->','H' in s1)
print('"H" not in s1 -->','H' not in s1)
print('\\r -->', R'\r')

运行效果如下：

s1 + s2 --> hellopython
s1 * 2 --> hellohello
s1[0] --> h
s1[0:2] --> he
"H" in s1 --> False
"H" not in s1 --> True
\r --> \r

（4）字符格式化

当我们需要输出的内容中含有变量时，此时便需要一种格式化字符串的方式，常用占位符如下表所示：

占位符	描述
%s	格式化字符串
%d	格式化整数
%f	格式化浮点数

Python 使用 % 格式化字符串，我们也可以使用字符串的 format() 方法进行格式化，以字符串为例：

print('Hello %s' % 'Python')
print('{0} {1}'.format('Hello', 'Python'))
print('{} {}'.format('Hello', 'Python'))
# 这种方式是用传入的参数依次替换字符串内的占位符{0}、{1} …

运行效果如下：

Hello Python
Hello Python
Hello Python

3、list列表类型

Python中没有数组，而是加入了功能更强大的列表（list），列表可以存储任何类型的数据，同一个列表中的数据类型还可以不同；列表是序列结构，可以进行序列结构的基本操作：索引、切片、加、乘、检查成员。

（1）创建、获取、更新、删除操作

#创建
#列表中所有元素都放在一个中括号 [] 中，相邻元素之间用逗号 , 分隔，如下所示：
l = [123, 0.8, 'hello Python']
#获取
#通过索引访问列表中的值，还可以使用 : 截取范围内的元素，如下所示：
l = [1024, 0.5, 'Python']
print('l[0] -->', l[0])
print('l[1:] -->', l[1:])
#更新
#除了对列表中现有元素进行修改外，还可以使用 append() 向列表中添加新元素，如下所示：
l = [1024, 0.5, 'Python']
#修改列表中第二个元素
l[1] = 5
#向列表中添加新元素
l.append('Hello')
print('l[1] -->', l[1])
print('l -->', l)
#删除
#使用 del 删除列表中元素，如下所示：
l = [1024, 0.5, 'Python']
#删除列表中第二个元素
del l[1]
print('l -->', l)

运行效果如下：

l[0] --> 123
l[1:] --> [0.8, 'hello Python']
l[1] --> 5
l --> [1024, 5, 'Python', 'Hello']
l --> [1024, 'Python']

（2）常用函数方法

#count()
#统计列表中某个元素出现的次数
l = ['d', 'b', 'a', 'f', 'd']
print("l.count('d') -->", l.count('d'))
#index()
#查找某个元素在列表中首次出现的位置（即索引）
l = ['d', 'b', 'a', 'f', 'd']
print("l.index('d') -->", l.index('d'))
#remove()
#移除列表中某个值的首次匹配项
l = ['d', 'b', 'a', 'f', 'd']
l.remove('d')
print("l -->", l)
#sort()
#对列表中元素进行排序
l = ['d', 'b', 'a', 'f', 'd']
l.sort()
print('l -->', l)
#copy()
#复制列表
l = ['d', 'b', 'a', 'f', 'd']
lc = l.copy()
print('lc -->', lc)

运行效果如下：

l.count('d') --> 2
l.index('d') --> 0
l --> ['b', 'a', 'f', 'd']
l --> ['a', 'b', 'd', 'd', 'f']
lc --> ['d', 'b', 'a', 'f', 'd']

4、tuple元组类型

元组（tuple）与列表类似，但元组是不可变的，可简单将其看作是不可变的列表，元组常用于保存不可修改的内容。

（1）创建、获取、更新、删除操作

#创建
#元组中所有元素都放在一个小括号 () 中，相邻元素之间用逗号 , 分隔，如下所示：
t = (1024, 0.5, 'Python')
#访问
#与访问列表中元素类似，如下所示：
t = (1024, 0.5, 'Python')
print('t[0] -->', t[0])
print('t[1:] -->', t[1:])
#修改
#元组中元素不能被修改，我们要用重新赋值的方式操作，如下所示：
t = (1024, 0.5, 'Python')
t = (1024, 0.5, 'Python', 'Hello')
print('t -->', t)
#删除
#元组中的元素不能被删除，我们只能删除整个元组，如下所示：
t = (1024, 0.5, 'Python')
del t
print('t -->', t)
#由于元组实例被删除，所以输出了异常信息。

运行效果如下：

Traceback (most recent call last):
  File "code.py", line 18, in <module>
    print('t -->', t)
NameError: name 't' is not defined
t[0] --> 1024
t[1:] --> (0.5, 'Python')
t --> (1024, 0.5, 'Python', 'Hello')

（2）常用函数方法

#len()
#计算元组中元素个数，使用如下所示：
t = (1024, 0.5, 'Python')
print('len(t) -->', len(t))
#max() 和 min()
#返回元组中元素最大、最小值，使用如下所示：
t = ('d', 'b', 'a', 'f', 'd')
print('max(t) -->', max(t))
print('min(t) -->', min(t))
#tuple()
#将列表转换为元组，使用如下所示：
l = ['d', 'b', 'a', 'f', 'd']
t = tuple(l)
print('t -->', t)

运行效果如下：

len(t) --> 3
max(t) --> f
min(t) --> a
t --> ('d', 'b', 'a', 'f', 'd')

5、序列类型

Python中的序列是一块可存放多个值的连续内存空间，所有值按一定顺序排列，每个值所在位置都有一个编号，称其为索引，我们可以通过索引访问其对应值。

常见的序列结构包括字符串、列表、元组等。

（1）创建、获取、更新、删除操作

# 索引
# 序列索引支持非负数和负数，索引为非负数，从 0 开始
# 索引为负数由右向左计数，从 -1 开始，如图所示
# 从结果来看，我们使用非负数索引与负数索引得到的结果一致。
str = 'Python'
print('str[0] str[-6] =', str[0], str[-6])
print('str[5] str[-1] =', str[5], str[-1])
# 切片
# 切片操作可以访问一定范围内的元素，语法如下：sname[start : end : step]
# sname：表示序列的名称；
# start：开始索引位置（包括该位置），默认为 0；
# end：表示切片的结束索引位置（不包括该位置），默认为序列的长度；
# step：步长。
str = 'Python'
print(str[:3])
print(str[3:])
print(str[:])
# 相加
# Python 支持类型相同的序列使用 + 作相加操作，该操作不会去除重复的元素。以字符串为例，如下所示：
str1 = 'Python'
str2 = 'Python'
print('str1 + str2 --> ',str1 + str2)
# 相乘
# Python 中，使用数字 n 乘以一个序列会生成新的序列，内容为原来序列被重复 n 次的结果。以字符串为例，如下所示：
str = 'Python'
print('2 * str --> ',2 * str)
# 检查元素是否包含在序列中
# Python 使用 in 关键字检查某元素是否为序列的成员，语法如下：val in seq
# val：要检查的元素；
# seq：指定的序列。
str = 'Python'
print('on'in str)

运行效果如下：

str[0] str[-6] = P P
str[5] str[-1] = n n
Pyt
hon
Python
str1 + str2 -->  PythonPython
2 * str -->  PythonPython
True

（2）常用的函数方法

函数	描述
len()	计算序列的长度
max()	找出序列中的最大元素
min()	找出序列中的最小元素
list()	将序列转换为列表
str()	将序列转换为字符串
sum()	计算元素的和
sorted()	对元素进行排序
enumerate()	将序列组合为一个索引序列，多用在 for 循环中

简单举几个例子，如下所示：

str = 'ABCDKF'
print('len -->', len(str))
print('max -->', max(str))
print('sorted -->', sorted(str))

运行效果如下：

len --> 6
max --> K
sorted --> ['A', 'B', 'C', 'D', 'F', 'K']

6、字典类型

dict是python中的一个可变的数据类型，用{}表示，dict的key必须是不可变的数据类型，而value的数据类型可以任意格式：{key:value,key:value,key:value}，dict 拥有良好的查询速度，dict 中的值可以是任意 Python 对象，多次对一个 key 赋 value，后面的 value 会把前面的 value 覆盖。
注：键值对如果是字符串使用单引号，最后一个键值对没有逗号
dict的优点：
①：查询速度快，可以二分查找
②：key是不可以重复的

其中：
不可变数据类型： 元组，bool，int , str 或hash
可变数据类型： dict ，list 或 set

字典的内容在花括号 {} 内，键-值（key-value）之间用冒号 : 分隔，键值对之间用逗号 , 分隔，比如创建字典 d，如下所示所有操作：

# 创建
#使用 dict 函数
#方式一
l = [('name', '小明'), ('age', 18)]
d = dict(l)
#方式二
d = dict(name='小明', age='18')
#空字典
d = dict()
d = {}
# 获取
#字典中的值通过 key 进行访问，如下所示：
d = dict(name='小明', age='18')
d['name']
# 使用 get 方法
# 字典的get()方法：使用get()方法可以查询某个键是否存在，如果不存在此键，则会返回None，但是可以在get()方法中添加信息避免出现None
print(d.get('name'))
print(d.get('address')) # None
print(d.get('address','没有此键'))  #没有此键
# 修改
#修改操作，以修改 age 为例，如下所示：
d = dict(name='小明', age='18')
d['age'] = '20'
#调用update()修改
d={'name':"Jordan",'age':18}
d1={'address':'kb','age':22}
d.update(d1)
print(d)
# 删除
# 使用pop(keyName)删除，如果有键，则删除，如果没有则会报错，如果不希望出现报错信息，可以在删除的后面添加信息
d = dict(name='小明', age='18')
print(d.pop('age'))
print(d.pop('other','没有此键'))
# 使用popitem()删除，随机删除，返回的是一个元组，元组里面存储的删除的键值，推荐使用pop()方法进行删除
print(d.popitem())  #随机删除，返回值是删除的键值对
# 使用del删除，del可以删除整个字典，也可以删除字典的某个键，如果删除的键不存在，则会出现报错
del d['name']
# 使用del清空列表
del d
# 清空字典：
d.clear()
# 获取字典的长度
d = dict(name='小明', age='18')
len(d)
# 字典的查询
# 查询字典的键：调用keys()方法
# 查询字典的值：调用values()方法
# 字典的查
print(d.keys()) 
print(d.values()) 
print(d.items())
#打印d的键
for i in d.keys():
    print(i)  # name age value
#打印d的值
for v  in d.values():
    print(v)
#打印字典的键值：
for i in d.items():
    print(i)  # ('name', 'jinxin') ('age', 18) ('male', '男')
for k,v in d.items():
    print(k,v)  # name jinxin  age 18   male 男

运行效果如下：

Traceback (most recent call last):
  File "code.py", line 37, in <module>
    del d['name']
KeyError: 'name'
小明
None
没有此键
{'name': 'Jordan', 'age': 22, 'address': 'kb'}
18
没有此键
('name', '小明')

7、集合类型

集合（set）与字典相同均存储 key，但也只存储 key，因 key 不可重复，所以set的中的值不可重复，也是无序的。
使用
集合使用花括号 {} 或者 set() 函数创建，如果创建空集合只能使用 set() 函数，以创建集合 s 为例，如下所示：

s = {'a', 'b', 'c'}
#使用 set 函数
s = set(['a', 'b', 'c'])
#空集合
s = set()
# 集合中重复的元素会被自动过滤掉，如下所示：
s = {'a', 'a', 'b', 'c', 'c'}
s
{'a', 'c', 'b'}
# 添加元素可以使用 add 或 update 方法，如果元素已经存在，则不进行操作，如下所示：
s = {'a', 'b', 'c'}
s.add('d')
s.update('e')
# 添加已经存在的元素 a
s.add('a')
# 删除元素使用 remove 方法，如下所示：
s = {'a', 'b', 'c'}
s.remove('c')
# 清空集合使用 clear 方法，如下所示：
s = {'a', 'b', 'c'}
s.clear()
# 获取集合的长度，同样使用 len 方法，如下所示：
s = {'a', 'b', 'c'}
len(s)

8、时间类型

time 模块提供了很多与时间相关的类和函数，下面我们介绍一些常用的。
localtime() 表示当前时间，返回类型为struct_time对象，可以通过索引和属性名访问值.

（1）属性值

索引	属性	值
0	tm_year（年）	如：1945
1	tm_mon（月）	1 ~ 12
2	tm_mday（日）	1 ~ 31
3	tm_hour（时）	0 ~ 23
4	tm_min（分）	0 ~ 59
5	tm_sec（秒）	0 ~ 60
6	tm_wday（周）	0 ~ 6
7	tm_yday（一年内第几天）	1 ~ 366

示例代码如下：

import time
t = time.localtime()
print('t-->', t)
print('tm_year-->', t.tm_year)
print('tm_year-->', t[0])

运行效果如下：

t--> time.struct_time(tm_year=2020, tm_mon=4, tm_mday=14, tm_hour=15, tm_min=34, tm_sec=33, tm_wday=1, tm_yday=105, tm_isdst=0)
tm_year--> 2020
tm_year--> 2020

（2）常用函数

函数（常量）	说明
time()	返回当前时间的时间戳
gmtime([secs])	将时间戳转换为格林威治天文时间下的 struct_time，可选参数 secs 表示从 epoch 到现在的秒数，默认为当前时间
localtime([secs])	与 gmtime() 相似，返回当地时间下的 struct_time
mktime(t)	localtime() 的反函数
asctime([t])	接收一个 struct_time 表示的时间，返回形式为：Mon Dec 2 08:53:47 2019 的字符串
ctime([secs])	ctime(secs) 相当于 asctime(localtime(secs))
strftime(format[, t])	格式化日期，接收一个 struct_time 表示的时间，并返回以可读字符串表示的当地时间
sleep(secs)	暂停执行调用线程指定的秒数

示例代码如下：

import time
print(time.gmtime())
print(time.localtime())
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))

运行效果如下：

import time
print(time.gmtime())
print(time.localtime())
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))

其中：日期格式化符号说明如下：

符号	说明
%a	本地化的缩写星期中每日的名称
%A	本地化的星期中每日的完整名称
%b	本地化的月缩写名称
%B	本地化的月完整名称
%c	本地化的适当日期和时间表示
%d	十进制数 [01,31] 表示的月中日
%H	十进制数 [00,23] 表示的小时（24小时制）
%I	十进制数 [01,12] 表示的小时（12小时制）
%j	十进制数 [001,366] 表示的年中日
%m	十进制数 [01,12] 表示的月
%M	十进制数 [00,59] 表示的分钟
%p	本地化的 AM 或 PM
%S	十进制数 [00,61] 表示的秒
%w	十进制数 [0(星期日),6] 表示的周中日
%x	本地化的适当日期表示
%X	本地化的适当时间表示
%y	十进制数 [00,99] 表示的没有世纪的年份
%Y	十进制数表示的带世纪的年份

好的，感谢各位阅读完本篇博文，也非常感谢网内的同仁的分享，在写本博文的时候也借鉴和参考了他们的实践经验和总结，在此表示感谢！
我也秉承资源共享的原则，把本次花费近一个星期整理出来的稿分享给大家，希望能对大家有所帮助，少走弯路，提高效率！
回到本博文的起点，这些基本概念，将会是我们进入python世界的非常重要的第一课，让我们一起学习和共同成长吧！