千里之行 | 基本数据类型

一. 几个概念

1. 表达式

• 表达式是指由数字、算符、数字分组符号、自由变量和约束变量等以能求得数值的有意义排列方法所得的组合
• 表达式的特点：
  ♦ 表达式一般仅仅用于计算一些结果，不会对程序产生实质性的影响；
  ♦ 如果在交互模式中输入一个表达式，解释器会自动将表达式的结果输出；

2. 语句

• 一个语法上自成体系的单位，它由一个词或句法上有关联的一组词构成；
• 语句的执行一般会对程序产生一定的影响，在交互模式中不一定会输出语句的执行结果；

3. 程序

• 程序是由一条一条的语句和一条一条的表达式构成的。

4. 函数

• 函数是一种语句，函数专门用来完成特定的功能；
• 函数长的形如：XXX( )
• 函数的分类：
  ♦ 内置函数（或内建函数）：是由语法规定存在的函数，这些函数，包含在编译器的运行库中，程序员不必单独书写代码实现它，只需要调用即可；
  ♦ 自定义函数：由程序员自主创建的函数，当我们需要完成某个功能时，可以调用内置函数，或者自定义函数；
• 函数的两个要素：
  ♦ 参数；
  ♦ 返回值；

二. 标识符

1. 关键字

• Python具有一些有特特殊功能的标识符，这就是所谓的关键字，是python已经使用的了，所以不允许开发者自己定义和关键字相同的名字的标识符；

Python关键字（保留字）
False	await	else	import	pass
None	break	except	in	raise
True	class	finally	is	return
and	continue	for	lambda	try
as	def	from	nonlocal	while
assert	del	global	not	with
async	elif	if	or	yield

2. 标识符概念

• 标识符是指程序中自定义的一些符号和名称。标识符是自己定义的，如变量名、函数名等；
• 组成：由26个英文字母（区分大小写），数字0-9，符号_$;
• 标识符的规则：
  ♦ 1. 标识符中可以包含字母、数字、_，但是不能使用数字开头，例 如：name1，但1name不行；
  ♦ 2. Python中不能使用关键字和保留字来作为标识符;
• 命名方式：
  ♦ 1. 小驼峰式命名法：第一个单词以小写字母开始；第二个单词的首字母大写，如：myName、aDog
  ♦ 2. 大驼峰式命名法：每一个单词的首字母都采用大写字母，如：FirstName、LastName
• 下划线命名法
  -♦ 1. 在程序员中还有一种命名法比较流行，就是用下划线“_"来连接所有的单词，比如get_url、buffer_size

三. 基本数据类型

数据类型指的就是变量值的类型，也就是可以为变量赋哪些值；

1. 整数和小数

• 整数：所有整数：如：a = 0、b = 100、c = 999都是int类型；
• 小数常量：所有小数，如：a = 1.2、b = 6.666用float类型表示；

2. 布尔值和空值

• 布尔值：只有两个值，一个是True，一个是False。布尔值可以理解为一种特殊的整型，True就是1，False就是0；
• None常量：只有一个数值就是None也就是空值；

>>> print(True + 1)
2

四. 变量

1. 变量的概念？

• 变量是计算机内存中的一快区域，存储规定范围内的值，值可以改变，变量就是给数据起的名字；
• 变量的命名规则；
   （1）变量名由字母、数字、下划线组成，其命名要符合标识符的命名规范；
   （2）数字不能开头；
   （3）不能使用关键字；
• 注意：两个对象相等和两个对象是同一个对象是两个概念；

2. 变量的运算

• 变量的运算就是正常的四则运算，需要注意的是在运算过程中含有浮点数时，那么它返回的就是一个浮点数类型；

>>> print(1 + 2）
3
>>> print(1.0 + 2)
3.0
>>> pirnt(1 * 2)
2
>>> print(1 * 2.0)
2.0

五. 字符串

1. 什么是字符串

• 字符串是由数字、字母、下划线组成的一串字符；
• 注意
   （1）单引号和双引号不能混合使用；
   （2）Python中用一对双引号或者一对单引号包裹的内容就是字符串；

2. 转义字符

• 转义字符是一种特殊的字符常量。转义字符以反斜线""开头，后跟一个或几个字符。转义字符具有特定的含义。不同于字符原有的意义，故称“转义”字符；
• 总结

常用转义字符
\t	制表符
\n	换行符
\\	反斜杠
\'	'
\"	"

3. 长字符串

• 长字符串，又叫做文档字符串，我们使用三重引号来表示一个长字符串’’’ ‘’’
• 三重引号可以换行，并且会保留字符串中的格式

4. 格式化字符串

• 第一种格式化字符串 拼串
• 第二种格式化字符串 参数传递
• 第三种格式化字符串 占位符
   （1）%s 字符串占位；
   （2）%f 浮点数占位；
   （3）%d 整数占位；
  -第四种格式化字符串
    f’{变量}’/ str.format

5. 字符串的其他操作

• len( ) 获得字符串的长度；
• max( ) 找最大值；
• min( ) 找最小值；
• split( ) 分割字符串；
• join( ) 拼接字符串；
• 去空格
   （1）s.strip( ) 左右两边去空格；
   （2）s.lstrip( ) 去左边空格；
   （3）s.rstrip( ) 去右边空格；
• 字符串大小写
   （1）s.upper( ) 全部大写；
   （2）s.lower( ) 全部小写；
   （3）判断是不是大写；
   （4）判断是不是小写；

六. 扩展：字符串格式化的几种方式

1. %运算符格式化字符串

• 如何使用
  字符串对象都有一个使用%运算符完成的內置操作，可被用来格式化字符串。最简单的如：

In [11]: name = "Monty Python"
In [12]: "Hello, %s." % name
Out[12]: 'Hello, Monty Python.'

如果想要对一段字符串中插入多个变量进行格式化，则需要使用一个元组将待插入变量包在一起，如：

In [14]: name = "Monty Python"
 
In [15]: age = 100
 
In [16]: "Hello, %s. You are %d years old" % (name, age)
Out[16]: 'Hello, Monty Python. You are 100 years old'

• 缺点概述
  使用%运算符的方式来格式化字符串自Python语言诞生之日起就已存在，上述代码看起来也很直观易读，但是当字符串更长，待插入变量更多，则使用%来格式化字符串的可读性将急剧下降，如：

In [23]: first_name = "Eric"
 
In [24]: last_name = "Idle"
 
In [25]: age = 100
 
In [26]: profession = "comedian"
 
In [27]: affiliation = "Monty Python"
 
In [28]: "Hello, %s %s. You are %s. You are a %s. You were a member of %s." % (first_name, last_name, age, profession, affiliation)
Out[28]: 'Hello, Eric Idle. You are 100. You are a comedian. You were a member of Monty Python.'

上述使用%格式化字符串不仅冗长，而且容易出错，因为这种方式并不够正确显示元组或者字典。

实际上，在Python官方文档中，对于使用%运算符格式化字符串这种方式的评价也是负面的：
♦ The formatting operations described here exhibit a variety of quirks that lead to a number of common errors (such as failing to display tuples and dictionaries correctly).使用%格式化字符串会产生一系列异常，这些异常将引起一系列常见错误（如：无法正确显示元组和字典）。
♦ Using the newerformatted string literals, the str.format() interface, ortemplate strings may help avoid these errors.使用更新的格式化字符串字面量（f-string：formatted string literals），str.format()接口或者模板字符串（template strings）可以帮助避免这些错误。
♦ Each of these alternatives provides their own trade-offs and benefits of simplicity, flexibility, and/or extensibility.
当然，上述三种可替代的格式化字符串方式也都在简洁、灵活和可扩展方面有所取舍。

2. str.format()格式化字符串

• 如何使用
  str.format()是对使用%实现格式化字符串的一种改进。这种方式使用的语法和普通函数调用相差无几。
  使用str.format()，字符串中待替换的域使用{}表示：

In [29]: name = "Eric"
 
In [30]: age = 100
 
In [31]: "Hello, {}. You are {}.".format(name, age)
Out[31]: 'Hello, Eric. You are 100.'

也可以通过索引的方式指定format()中哪一个变量和值应该填入哪一个{}，如：

In [32]: name = "Eric"
 
In [33]: age = 100
 
In [34]: "Hello, {1}. You are {0}.".format(age, name)
Out[34]: 'Hello, Eric. You are 100.'

除了索引，也可以通过在{}中指定名称的方式来实现类似上述功能，如：

In [36]: name = "Eric"
 
In [37]: age = 100
 
In [38]: "Hello, {name}. You are {age}.".format(age=age, name=name)
Out[38]: 'Hello, Eric. You are 100.'

基于上面的方式，当待格式化的信息都来自一个字典时，Python中还有如下骚操作：

In [39]: person = {'name': 'Eric', 'age': 100}
 
In [40]: "Hello, {name}. You are {age}.".format(name=person['name'], age=person['age'])
Out[40]: 'Hello, Eric. You are 100.'

更骚的是，上面的骚操作还能利用字典拆包**进一步简化：

In [41]: person = {'name': 'Eric', 'age': 100}
 
In [42]: "Hello, {name}. You are {age}.".format(**person)
Out[42]: 'Hello, Eric. You are 100.'

• 缺点概述
  相较于%运算符方式，使用str.format()已经使得格式化字符串语法更加可读，但是当变量增多时，这种方式写出的程序也会显得很冗长：

In [43]: first_name = "Eric"
 
In [44]: last_name = "Idle"
 
In [45]: age = 74
 
In [46]: profession = "comedian"
 
In [47]: affiliation = "Monty Python"
 
In [48]: print(("Hello, {first_name} {last_name}. You are {age}. " +
  ...: "You are a {profession}. You were a member of {affiliation}.") \
  ...: .format(first_name=first_name, last_name=last_name, age=age, \
  ...: profession=profession, affiliation=affiliation))
Hello, Eric Idle. You are 74. You are a comedian. You were a member of Monty Python.

3. f-string格式化字符串

• 在Python 3.6中f-string被引入（具体请见PEP 498），也被称作格式化字符串字面量（formatted string literals）。
• f-string是字符串字面量，且其以字母f开头，{}中包含变量或表达式，变量或表达式将在运行（runtime）时通过使用__format__协议被替换成具体的值。
• 如何使用
  简单的f-string格式化字符串如：

In [49]: name = "Eric"
 
In [50]: age = 100
 
In [51]: f"Hello, {name}. You are {age}."
Out[51]: 'Hello, Eric. You are 100.'

如前所述，{}中除接受变量外，还接受表达式，如：

In [52]: f"{2 * 37}"
Out[52]: '74'

f-string更强大的地方在于，{}中接受函数调用：

In [53]: def to_lowercase(input):
  ...:   return input.lower()
  ...: 
 
In [54]: name = "Eric Idle"
 
In [55]: f"{to_lowercase(name)} is funny."
Out[55]: 'eric idle is funny.'

甚至，可以对创建于类的对象使用f-string，如：

class Comedian:
  def __init__(self, first_name, last_name, age):
    self.first_name = first_name
    self.last_name = last_name
    self.age = age
 
  def __str__(self):
    return f"{self.first_name} {self.last_name} is {self.age}."
 
  def __repr__(self):
    return f"{self.first_name} {self.last_name} is {self.age}. Surprise!"
 
 
def main():
  new_comedian = Comedian("Eric", "Idle", "74")
  print(f"{new_comedian}")
 
 
if __name__ == '__main__':
  main()

上述代码的输出为：

Eric Idle is 74.

4. 模板字符串

• 对Python字符串，除了比较老旧的%，以及用来替换掉%的format，及在python 3.6中加入的f这三种格式化方法以外，还有可以使用Template对象来进行格式化。
  from string import Template，可以导入Template类。
  实例化Template类需要传入一个Template模板字符串。

class Template(metaclass=_TemplateMetaclass):
  """A string class for supporting $-substitutions."""
 
  delimiter = '$'
  idpattern = r'[_a-z][_a-z0-9]*'
  flags = _re.IGNORECASE
 
  def __init__(self, template):
    self.template = template

字符串默认以%作为定界符

# 默认的定界符是$，即会将$之后内容匹配的字符串进行替换
s = Template('hello, $world!')
print(s.substitute(world='python'))
# hello, python!

实例化Template之后，返回对象s，调用对象s的substitute，传入替换的数据，最终返回替换之后的结果。
如果需要对定界符进行修改，可以创建一个Template的子类，在子类中覆盖掉Template的类属性delimiter，赋值为需要重新设定的定界符。

# 可以通过继承Template类的方式进行替换
class CustomerTemplate(Template):
  delimiter = '*'
 
t = CustomerTemplate('hello, *world!')
print(t.substitute(world='python'))
# hello, python!

上面的例子中，输出和未修改定界符之前是一样的，都是hello, python!