python学习之路-基本数据类型1 变量的概念、数字、字符串

1 什么是数据类型？

每种编程语言都有自己的数据类型，用于标识计算机可以认识的数据，Python中主要的数据类型为字符串，整数，浮点数，列表，元祖，字典，集合七种主要的数据类型，其中以列表，字典为最主要的数据类型。

2 什么是变量？

在说数据类型之前，首先说一下变量，那什么是变量？简单讲，变量就是一个容器，用来装东西的，可以装不同的东西。如一个瓶子，可以拿去装酱油，也可以拿去装可乐；其中瓶子就是一个变量，我们可以给瓶子起个名字，就是变量名，而瓶子中装的酱油和可乐就是不同的数据类型。

2.1 变量及其命名规则

2.1.1变量的命名规则

只允许使用字母、数字和下划线。
变量名可以字母或下划线打头，但不能以数字打头，例如，可将变量命名为message_1，但不能将其命名为1_message。
变量名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greeting_message可行，但变量名greeting message会报错。
不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，如print。
变量名应既简短又具有描述性。例如，name比n好，student_name比s_n好，name_length比length_of_persons_name好。
慎用小写字母l和大写字母O，因为它们可能被人错看成数字1和0。

2.1.2 变量的命名原则

驼峰式
下划线式

2.1.3 使用变量时避免命名错误

名称错误通常意味着两种情况：

要么是使用变量前忘记了给它赋值，
要么是输入变量名时拼写不正确。

3 python中的数据类型

下面将Python中主要的数据类型分数字，字符串，列表，元祖，字典，集合六种类型进行总结。

3.1 数字

Python的数字也有4中不同的类型，分别是：整数（int）、浮点数（float）、布尔值（bool）、复数（complex）。
Python将带小数点的数字都称为浮点数。

3.1.1 整数

简单理解，整数就是没有小数点的数！例如0，-1，23333333，整数的准确概念可参考该内容
Python中的整数又有不同的进制，如十进制，二进制，十六进制，八进制。
现在不懂进制没关系，想了解的话可以百度，我就不长篇大论了。
他们之间的相互转化可以参考该内容

十进制写法就是正常写法；
二进制写法加前缀0b，且只能出现0 1两种数字的组合，例如：0b1001110；
八进制写法加前缀0o，出现0~7数字组合，例如0o76543210；
十六进制写法加前缀0x，出现0~9和A~F的数字和字母组合，例如0xA20974BCF；
运行时，他们会自动转为十进制输出结果，我们试试：

print(0b100110)  # 二进制
# 结果：38

print(0o7654321)  # 八进制
# 结果：2054353</pre>

print(0xA20974BCF)  # 十六进制
# 结果：43496459215

print(0xABCD)  # 十六进制
# 结果：43981

3.1.2 浮点数

简单点说，浮点数就是带小数点的数字。
划重点：浮点数只能以十进制方式书写，也就是不加前缀。

3.1.3 整数型与浮点型的区别

整数型和浮点型都是数字，区别在于：

整数型对应的是数学中的整数；
浮点型可以看作是实数（暂不考虑精度问题），即带小数点的数。
在python中数字5 和5.0使用不同的数据类型表示，数字5为整数型，5.0为浮点型。

3.1.4 布尔值

布尔值就是我们常说的逻辑值，可以理解为对或者错，正面与反面。

3.1.5 复数

复数是什么？
有理数和无理数统称实数，在实数之外还有一种叫复数，一般用不到，了解一下就可以了。
在Python中，复数是这样表示的：

 print(1+1j)
# 结果：(1+1j)

print(type(1+1j))
# 结果：complex

3.1.6 可以使用type()函数来查看变量的类型

type(10)
# 结果：int

type(10.3)
# 结果：float

print(type('10.3'))
# 结果：str

3.1.7 可以使用 isinstance()函数来判断变量是否为某一类型

print(isinstance(2,int))
# 结果：True

print(isinstance(2.0,int))
# 结果：False

3.2 字符串

3.2.1 字符串的定义

在Python中，用引号包起的都被称为字符串，其中引号可以是单引号（‘’），也可以是双引号（“”）和三引号（''' ''' 或""" """）

name = 'zhang san'
str = 'good morning!'

print(str,name)
# 结果：goodmorning! zhang san

3.2.2 字符串的格式化输出

在很多时候，我们需要在字符串中放置变量，然后用变量的值替换，python中字符串的格式化输出有两种方式：

3.2.2.1使用%() 实现字符串格式化输出

具体使用方法如下：

name = 'zhang san'
age = 22
job = 'student'
str = "my name is %s,I'm %d years old,I'm a %s." %(name,age,job)
print(str)
# 结果：my name is zhang san,I'm 22 years old,I'm a student.

其中%s代表字符串变量，%d代表整数型变量。

常见的格式化字符：

格式	描述
%%	百分号标记 ,就是输出一个%
%c	字符及其ASCII码
%s	字符串
%d	有符号整数(十进制)
%u	无符号整数(十进制)
%o	无符号整数(八进制)
%x	无符号整数(十六进制)
%X	无符号整数(十六进制大写字符)
%e	浮点数字(科学计数法)
%E	浮点数字(科学计数法，用E代替e)
%f	浮点数字(用小数点符号)
%g	浮点数字(根据值的大小采用%e或%f)
%G	浮点数字(类似于%g)
%p	指针(用十六进制打印值的内存地址)
%n	存储输出字符的数量放进参数列表的下一个变量中

其中，最常用的为%s,%d,%f,%e。

3.2.2.2 使用format()函数实现字符串格式化输出

name = 'zhang san'
age = 22
job = 'student'

# 方式一：
str = "my name is {name},I'm {age} years old,I'm a {job}." .format(name=name, age = age, job = job)
print(str)
# 结果： my name is zhang san,I'm 22 years old,I'm a zhang san.</pre>

# 方式二：
str = "my name is {0},I'm {1} years old,I'm a {2}." .format(name, age, job)
print(str)
# 结果： my name is zhang san,I'm 22 years old,I'm a zhang san.

其他用法：

age = 25
name = 'Caroline'

print('{0:.3} is a decimal. '.format(1/3))  # 小数点后三位
# 结果：0.333 is a decimal.

print('{0:_^11} is a 11 length. '.format(name))  # 使用_补齐空位
# 结果：_Caroline__ is a 11 length.

print('My name is {0.name}'.format(open('out.txt', 'w')))  # 调用方法
# 结果：My name is out.txt

print('My name is {0:8}.'.format('Fred'))  # 指定宽度
# 结果：My name is Fred

3.2.3 转义

转义转义，顾名思义，就是转换含义，通俗的说就是改变原来的意思
Python用反斜杠（）来转义字符

转义字符	描述
(在行尾时)	续行符
\	反斜杠符号
'	单引号
"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy代表的字符，例如：\o12代表换行
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

3.2.4.字符串常用操作方法

对字符串的操作，常用的操作主要包括查看字符串长度，索引和切片，分割和拼接字符串，字符串格式的判断和修改，字符串填充，字符串子串的查找和替换等操作

3.2.4.1 查看字符串长度

用len（）函数查看字符串的长度

a = 'zhang san'
print(len(a))
# 结果：9

b = "你好"
print(len(b))
# 结果：2

由上面两个例子可以看出，len()函数查看的是字符串中字符的数量，其还可以查看列表，元祖，字典中的长度，下面会提到。

3.2.4.2 提取字符串中的子串（索引和切片）

单个字符串的提取用索引，多个字符串的提取用切片
字符串的索引：
Python有两种索引方式：

从前往后的正向索引：有m个字符长度的字符串，索引值是0~m-1（计算机很多都是从0开始标序号的）
从后往前的负数索引：有m个字符长度的字符串，索引值是-1~-m

name = 'zhangsan'
print(name[0])
# 结果：'z'

name = 'zhangsan'
print(name[-3])
# 结果： 's'

字符串的切片：
切片：顾名思义，就是把东西切成片，如果把字符串看成一根黄瓜，切片就是切出一个黄瓜片，黄瓜片的厚度就代表了切出来的字符串的长度。
我们来想一下，如果要从一根黄瓜里面切出一个黄瓜片，一般是要切两刀，在黄瓜的某个位置切一刀，然后根据所需黄瓜片的厚度，在另外的一个位置再切一刀，黄瓜片就产生了。当然，如果我们从头开始切，那第一刀就不用切了，只要根据想要黄瓜片的厚度在相应位置切一刀就可以产生一个黄瓜片，同理，我们想要黄瓜的结尾部分，只要切一刀就可以了，后面的部分也是一个黄瓜片。所以，切片的语法就类似我们切黄瓜片，需要三个参数，开始的位置，结束的位置，每刀切多厚。
切片标准的写法是用两个冒号分割三个数字,代表的意思分别是：

第一个数字表示切片的开始位置（索引），可以为正值也可以为负值（参考字符串索引的用法），省略为0，即索引为0开始取。
第二个数字表示切片的截至位置，但是不包括这个位置，也就是切到它的前一个位置结束（索引），可以为正值也可以为负值，省略代表取到最后。
第三个表示切片的步长（切片的厚度），当省略步长时候，默认为1，可以省略，省略后冒号也可以省略，也可以为负数，代表逆序取。
三个数全部省略，表示取字符串的全部，相当于没切。

name = 'zhang san'

print(name[1:4] ) # 从第2个位置切到第4个位置
# 结果：'han'
print(name[1:4:2])  # 从第2个位置切到第4个位置，步长为2
# 结果：'hn'
print(name[1:]) # 从第2个位置切到最后
# 结果：'hang san'
print(name[::])  # 切出所有
# 结果：'zhang san'
print(name[::2] ) # 切出所有，步长为2
# 结果： 'zagsn'
print(name[::-1])  # 逆序字符串
# 结果： 'nas gnahz'
print(name[:5]) # 切出前5个字符
# 结果：'zhang'

3.2.4.3 字符串分割

1）、根据指定的分隔符将字符串分割为前，中，后三部分
一般为指定的分隔符前面为1部分，分隔符为一部分，剩下的为一部分，返回一个含有三个元素的元祖
partition(self, sep)方法从左面开始
rpartition(self, sep)方法从右面开始

name = 'zhangsan,lisi,wangwu,maliu'
name.partition("a")
# 结果： ('zh', 'a', 'ngsan,lisi,wangwu,maliu')

2）、根据指定的分割符分割，默认分隔符为空格
指定分隔符和最多分割几次，默认不限次数，返回的是列表
split(self, sep=None, maxsplit=None): 分割，从左侧开始，返回的是列表
rsplit(self, sep=None, maxsplit=None): 分割，从右侧开始，返回的是列表
splitlines(self, keepends=False):根据换行符进行分割，返回列表

name = """zhangsan，lisi，wangwu"""
print(name.split(sep = 'a',maxsplit=1))
# 结果：['zh', 'ngsan，lisi，wangwu']

name = """zhangsan，lisi，wangwu"""
print(name.rsplit(sep = 'a',maxsplit=1))
# 结果：['zhangsan，lisi，w', 'ngwu']

name = """zhangsan
lisi
wangwu
"""
print(name.splitlines())
# 结果： ['zhangsan ', 'lisi ', 'wangwu']

3.2.4.4 字符串拼接

1）、两个字符串拼接可以使用加号（+）来实现，如果想要将列表中的字符串全部拼接起来，可以使用join（）方法。

'my' +' '+ 'name' + ' '+ 'is' + ' ' + 'zhangsan'
# 结果： 'my name is zhangsan'

2）、join(self, iterable): 使用指定的连接符，将传入的列表中的各元素连接在一起

s = ','
a = s.join(['lisi','wangwu','maliu'])
print(a)
# 结果：  'lisi,wangwu,maliu'

join方法和split方法是相反的操作：

name = ['lisi', 'wangwu', 'maliu']

s = ','
a = s.join(['lisi', 'wangwu', 'maliu'])
print(a)
# 结果：lisi,wangwu,maliu

b = a.split(s)
print(b)
# 结果：['lisi', 'wangwu', 'maliu']

3.2.4.5 对字符串的格式进行判断和修改

1）、判断字符串是否为某种格式：

islower(self) 判断字符串是否为小写
isspace(self) 判断字符串是否为空字符串
istitle(self) 判断字符串是否为标题格式的字符串
isupper(self) 判断字符串是否全为大写
startswith(self, prefix, start=None, end=None) 判断字符串是否是以某个子串起始
endswith(self, suffix, start=None, end=None) 判断字符串是否以某个子串结束
isalnum(self): 是否是字母和数字
isalpha(self): 是否是字母
isdigit(self): 是否是数字

2）、使用方法修改字符串的格式：

title(self)以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。
upper(self)将字符串改为全部大写
lower(self)将字符串改为全部小写
capitalize(self)将首字母变为大写
def swapcase(self) 字符串大写变小写，小写变大写 """

name = 'zhang san'
job = 'IT'

print(name.title())
# 结果：Zhang San

print(name.upper())
# 结果：ZHANG SAN

print(job.lower())
# 结果：it

print(name.capitalize())
# 结果：Zhang san

print(name.title().swapcase())
# 结果：zHANG sAN

3.2.4.6 字符串填充及删除空白的相关方法

1）、使用制表符或换行符来添加空白

要在字符串中添加制表符，可使用字符组合\t
要在字符串中添加换行符，可使用字符组合\n

print('hello,zhang san')
# 结果：hello,zhang san

print('hello,\nzhang san')
# 结果：hello,
#            zhang san

print('hello,\tzhang san')
# 结果：hello,    zhang san

2）、删除空白

rstrip()：删除字符串末尾的空白，并不改变原变量值
lstrip()：删除字符串开头的空白
strip()：同时删除字符串开头和末尾的空白

name = '    zhang san    '

print('|' + name+'|',len(name))
# 结果： |    zhang san    | 17
print('|' + name.rstrip()+'|',len(name.rstrip()))
# 结果： |    zhang san| 13
print('|' + name.lstrip()+'|',len(name.lstrip()))
# 结果：|zhang san    | 13
print('|' + name.strip()+'|',len(name.strip()))
# 结果：|zhang san| 9

3）、将字符串填充为指定的长度

center(self, width, fillchar=None)将字符串填充为指定的长度，并将字符串置于中间，fillchar参数指定填充的符号，默认为空
ljust(self, width, fillchar=None)将字符串填充为指定的长度，并将字符串置于左侧，fillchar参数指定填充的符号，默认为空
rjust(self, width, fillchar=None)将字符串填充为指定的长度，并将字符串置于右侧，fillchar参数指定填充的符号，默认为空
zfill(self, width)：返回指定长度的字符串，原字符串右对齐，不满指定的长度，在前面填充0。

name = 'zhangsan'

print(name.center(50,'-'))
# 结果：---------------------zhangsan---------------------
print(name.ljust(50,'*'))
# 结果：zhangsan******************************************
print(name.rjust(50,'*'))
# 结果：******************************************zhangsan

print(name.zfill(20))
# 结果：000000000000zhangsan

3.2.4.7 对字符串的子串进行操作

1）、计算字符串中子串的个数
count(self, sub, start=None, end=None) 用于统计字符串中某个子串的个数，start为开始查找位置，end为结束查找位置，但不包括该位置。

name = 'zhangsan'
print(name.count('a'))  # 找’zhangsan‘这个字符串中有几个‘a’
# 结果： 2

name = 'zhangsan'
print(name.count('a',3))  # 从’zhangsan‘这个字符串的第三个位置即n开始找字符串中有几个‘a’
# 结果：1

name = 'zhangsan'
print(name.count('a',3,6))  # 从’zhangsan‘这个字符串的第三个位置（即n)开始，第6个位置(即a)结束（不包含）找字符串中有几个‘a’
# 结果：0

2）、寻找字符串中子串的位置
用于寻找字符串中的子串的索引位置，如果有多个以第一个找到为准。结果从0开始，如果没找到返回-1
find(self, sub, start=None, end=None): 从左侧开始找
rfind(self, sub, start=None, end=None): 从右侧开始找


name = 'zhangsan'
name.find('a')
# 结果： 2

name = 'zhangsan'
name.find('saw')
# 结果“： -1

name= 'zhangsan'
name.rfind('a')
# 结果： 6

用于寻找字符串中的子串的索引位置，如果有多个以第一个找到为准。结果从0开始，如果没找到报错
index(self, sub, start=None, end=None): 从左侧开始找
rindex(self, sub, start=None, end=None): 从右侧开始找

name= 'zhang san'
name.index('an')
# 结果：2

name= 'zhang san'
name.rindex('an')
# 结果：7

3）、替换字符串中子串的内容
replace(self, old, new, count=None): 将字符串中的子串替换为另外的子串

name= 'zhang san'
name.replace('a','e')
# 结果： 'zheng sen'

4）、将tab转换成空格，默认一个tab转换成8个空格
expandtabs(self, tabsize=None):

name = 'zhang\tsan'
names = name.expandtabs()
print(names)
# 结果： 'zhang   san'

3.2.4.8 字符串编码问题

在python中，字符编码普遍认为是个很麻烦的事情，只要记住unicode是万国码，其他任何其他编码形式想要相互转换编码格式，都需要先解码成unicode，然后再编码成想要转换的编码格式。
将字符串解码为unicode格式
decode(self, encoding=None, errors=None):

将unicode格式的字符串编码为指定的编码格式
encode(self, encoding=None, errors=None):

其他方法：
translate(self, table, deletechars=None) 转换
需要先做一个对应表，最后一个表示删除字符集合

intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab)
str = "this is string example....wow!!!"
print (str.translate(trantab))
# 结果： th3s 3s str3ng 2x1mpl2....w4w!!!