Python学习——Python基础

二，Python基础

笔记来源https://www.bilibili.com/video/BV1PE411c71h?p=2.

1，编程三步曲

• 1 获取数据
• 2.逻辑处理
• 3 显示结果

2，Python基础语法

2.1，注释

# 单行注释

'''
这是多行注释，使用单引号。
这是多行注释，使用单引号。
这是多行注释，使用单引号。
'''

"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""

2.2，标识符

• 在 Python 里，标识符由字母、数字、下划线组成。但不能以数字开头。

• Python 中的标识符是区分大小写的。

• 命名尽量见名知意，会影响到程序的可读性。

• 以下划线开头的标识符是有特殊意义的。

1. 以单下划线开头 _foo 的代表不能直接访问的类属性，需通过 类提供的接口进行访问，不能用 from xxx import * 而导入。

2. 以双下划线开头的 _ _ foo 代表类的私有成员，以双下划线开头和结尾的 _ _ foo _ _ 代表 Python 里特殊方法专用的标识，如 _ _ init _ _ () 代表类的构造函数。

2.3，保留字符

下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。

所有 Python 的关键字只包含小写字母。

2.4，行和缩进

学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。

缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。

以下实例缩进为四个空格:

if True:
	print(“True”)
else: 
	print("False")
  print("没有严格缩进"）
  print("在执行时会报错IndentationError: unindent does not match any outer indentation level")

• Python 可以同一行显示多条语句，方法是用分号 ; 分开，如：

print(" a"); print(b)

2.5，常用的基本函数

• 关注函数的使用，不关注实现的细节。
  即使用者不必关心实现者是如何实现的。
  

函数	作用/适用性
input()	等待并获取用户的输入
print()函数	将内容打印在控制台中
del 函数	删除此变量存储的对象地址，在必要时释放对象（此对象的引用计数为0时）
id()	返回变量存储的对象地址
type()	用来查询变量所指的对象类型

用例
>>> input("等待并获取用户的输入，用于获取用户输入")
>>> print("将内容打印在控制台中")
>>> del 变量名   
>>> id(变量名) 
>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

3，Python变量

3.1， 变量概念

• 定义：关联一个对象的标识符。变量名对应真实的内存地址，变量名是为了方便人类记忆。

• 命名规则：必须是字母或下滑线开头，后面跟字母，数字，下滑线。建议小写，多个单词以下划线隔开，且见名知意。

• 赋值：创建一个变量或改变一个变量绑定的数据。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

• 语法：

	变量 = 表达式
	变量名 = 数据
	变量名1=.... = 变量名n = 数据     #同时为多个变量赋值
	变量名1，变量名2 = 数据1，数据2    #为多个变量指定多个值，根据顺序分配

python的变量是没有类型的，被创建后才能明确。这也是python灵活的原因之一。

• 变量在内存中如何存储
  
  改变字符串这类不可变类型的变量，会直接创建新的字符串对象，并且替换掉变量中原来存储的对象的地址。

3.2， 变量类型

Python中6个标准数据类型,以及空值对象 None.

• Numbers（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）
• Set（集合）

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

空值对象作用示意图

3.2.1， Python数字

作用：用于存储数值。

定义：当你指定一个值时，Number对象就会被创建：

>>> var = 1
>>> var = 10
>>> del var
>>> var_a, var_b = 1,2
>>> del var_a, var_b

特点： 数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。

Python数字类型

类型	说明
int (有符号整型)
long (长整型 [ 也可以代表八进制和十六进制])	长整型也可以使用小写 l，但是还是建议您使用大写 L，避免与数字 1 混淆。Python使用 L 来显示长整型。long 类型只存在于 Python2.X 版本中，在 2.2 以后的版本中，int 类型数据溢出后会自动转为long类型。
float（浮点型）	小数：（包含正数，负数，0.0），科学计数法：e/E (+/-) 指数 1.23e-2 = 0.0123 ，1.23e2 = 123
complex (复数)	复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。
bool(布尔类型)	只有两个值 True False

进制问题

• 十进制，二进制(0b)，八进制(0o)，十六进制(0x)。

>>> number = 0b0101  # 二进制
>>> number
5
>>> number = 0o37 # 八进制
>>> number
31
>>> number = 0xA0F # 十六进制
>>> number
2575

python数字类型转换

python中内置了很多用于数据类型之间转换的函数，你只需要将数据类型作为函数名即可。

• 混合类型自动升级：
  1 + 2.14 返回结果是 3.14
  1 + 3.0 返回结果是 4.0

>>> int(x) #将x转换为一个整数。

>>> float(x) #将x转换到一个浮点数。

>>> str(x)  #将x转换为字符串

>>> bool(x) #转换为布尔类型
>>> bool(0),bool(0.0),bool(None)
false

>>> complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
>>> complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

小整数对象池

CPython中 -5至256 永远存在小整数池中，以便重复使用。

# 超过了256的数字，虽然数值一样，但是也是不同的对象。
>>> a = 500
>>> b = 500
>>> id(a)
140415261568816
>>> id(b)
140415231214125
# 在 0-256之间的数字，数值相同即为同一对象。
>>> c = 100
>>> d = 100
>>> id(c)
10917536
>>> id(d)
10917536

数字常用的函数

函数	描述
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
fabs(x)	返回数字的绝对值，如abs(-10) 返回 10.0
ceil(x)	返回上入整数，如math.ceil(4.1) 返回 5
floor(x)	返回下舍整数，如math.floor(4.9)返回 4
exp(x)	返回e的x次幂，如math.exp(1) 返回 2.718281828459045
log(x)	如math.log(math.e)返回1.0, math.log(100,10)返回2.0
max(x1, x2,…)	返回给定参数的最大值，参数可以为序列
min(x1, x2,…)	返回给定参数的最小值，参数可以为序列
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示
pow(x, y)	x**y 运算后的值
sqrt(x)	返回数字x的平方根

3.2.2， Python字符串

作用：表示文本。

定义：字符串或串（string）是由数字，数字，下划线组成的一串字符。

s = "a1a2...an"    #n>=0

特点1. 字符串列表的两种取值顺序，如下图：

• 从左到右索引默认0开始的，最大范围是字符串长度少1
• 从右到左索引默认-1开始的，最大范围是字符串开头
  

特点2： 字符串的截取。

• 也称为列表的的截取，可以使用 [头下标：尾下标]。
  [头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。
  其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。

实例：
str = 'Hello World!'
 
print str           # 输出完整字符串
print str[0]        # 输出字符串中的第一个字符
print str[2:5]      # 输出字符串中第三个至第六个之间的字符串
print str[2:]       # 输出从第三个字符开始的字符串
print str * 2       # 输出字符串两次
print str + "TEST"  # 输出连接的字符串

以上实例输出结果：

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

python转义字符

# 续行符号 (在结尾时)
>>> print("line1 \
....line2 \
....line3")
# 反斜杠符号 
>>> print("\\")
 \ 
# 单引号
print('\'')
'
# 双引号 
print("\"")
\"
# 响铃  执行后电脑有响声
print("\a")
# 退格(Backspace)  
>>> print("Hello \b World!")
Hello World!
# 空 
>>> print("\000")

>>> 
# 换行
>>> print("\n")


>>>
# 纵向制表符 
>>> print("Hello \v World!")
Hello 
       World!
>>>
# 横向制表符
>>> print("Hello \t World!")
Hello      World!
>>>
# 回车
>>> print("Hello\rWorld!")
Hello
World!
# 八进制数，y 代表 0~7 的字符，例如：\012 代表换行。
>>> print("\110\145\154\154\157\40\127\157\162\154\144\41")
Hello World!
# 十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行
>>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")
Hello World!

3.2.3， Python列表

作用： 列表可以完成大多数（有序）集合类的数据结构的实现。

定义：由一系列变量组成的可变序列容器 。

• 列表用 [ ] 标识，内部元素用逗号隔开。是 python 最通用的，使用最频繁的复合数据类型。

list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]

特点1: 列表的切割，列表切割之后还是列表，下标运算出来的结果才是列表中的元素

• 列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
 
print list               # 输出完整列表
print list[0]            # 输出列表的第一个元素
print list[1:3]          # 输出第二个至第三个元素 
print list[2:]           # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2       # 输出列表两次
print list + tinylist    # 打印组合的列表


#以上实例结果
['runoob', 786, 2.23, 'john', 70.2]
runoob
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['runoob', 786, 2.23, 'john', 70.2, 123, 'john']

列表的操作

3.2.4， Python元组

作用：相当于只读列表。

定义： 元组用 () 标识，内部元素用逗号隔开。
tuple = ( ‘runoob’, 786 , 2.23, ‘john’, 70.2 )

特点 ：不能二次赋值。

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
 
print tuple               # 输出完整元组
print tuple[0]            # 输出元组的第一个元素
print tuple[1:3]          # 输出第二个至第四个（不包含）的元素 
print tuple[2:]           # 输出从第三个开始至列表末尾的所有元素
print tinytuple * 2       # 输出元组两次
print tuple + tinytuple   # 打印组合的元组


#以上实例结果
('runoob', 786, 2.23, 'john', 70.2)
runoob
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('runoob', 786, 2.23, 'john', 70.2, 123, 'john')

3.2.5， Python字典

作用：字典可以完成大多数（无序）集合类的数据结构的实现。

定义： 字典用"{ }"标识。字典由索引(key)和它对应的值value组成。是除列表以外python之中最灵活的内置数据结构类型。
tinydict = {‘name’: ‘runoob’,‘code’:6734, ‘dept’: ‘sales’}

特点 ：典当中的元素是通过键来存取的，而不是通过偏移存取。

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
 
 
print dict['one']          # 输出键为'one' 的值
print dict[2]              # 输出键为 2 的值
print tinydict             # 输出完整的字典
print tinydict.keys()      # 输出所有键
print tinydict.values()    # 输出所有值


#以上实例结果
This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'runoob'}
['dept', 'code', 'name']
['sales', 6734, 'runoob']

3.2.6， Python集合

3.4， 格式化输出

3.1.1，整数的输出

• %o —— oct 八进制
• %d —— dec 十进制
• %x —— hex 十六进制

# %o —— oct 八进制
print('%o' % 20)    #>>> 24
# %d —— dec 十进制
print('%d' % 20)    #>>> 20
# %x —— hex 十六进制
print('%x' % 20)    #>>> 14

3.1.2，浮点数输出

（1）格式化输出

• %f ——保留小数点后面六位有效数字
  　　%.3f，保留3位小数位
• %e ——保留小数点后面六位有效数字，指数形式输出
  　　%.3e，保留3位小数位，使用科学计数法
• %g ——在保证六位有效数字的前提下，使用小数方式，否则使用科学计数法
  　　%.3g，保留3位有效数字，使用小数或科学计数法

# %f -- 保留小数点后面六位有效数字
print('%f'%1.11)   #>>> 1.110000
# %.3f -- 保留三位有效数字
print('%.3f'%1.11)  #>>> 1.110

# %e -- 保留小数点后面六位有效数字,使用科学计数法
print('%e'%1.11)    #>>> 1.110000e+00
# %.3e -- 保留3位小数位，使用科学计数法
print('%.3e'%1.11)  #>>> 1.110e+00

# %g -- 在保证六位有效数字的前提下，使用小数方式，否则使用科学计数法
print('%g'%111.111111111)  #只会获取6位 >>>111.111
# %g -- 取2位有效数字，自动转换为科学计数法
print('%.2g'%111.111)    #>>> 1.1e+02

（2）内置 round()函数

• round(number[, ndigits])
• 参数：
  number - 这是一个数字表达式。
  ndigits - 表示从小数点到最后四舍五入的位数。默认值为0。
• 返回值
  该方法返回x的小数点舍入为n位数后的值。
• 用法

1. round()函数只有一个参数，不指定位数的时候，返回一个整数，而且是最靠近的整数，类似于四舍五入，当指定取舍的小数点位数的时候，一般情况也是使用四舍五入的规则，
2. 但是碰到.5的情况时，如果要取舍的位数前的小数是奇数，则直接舍弃，如果是偶数则向上取舍。
   注：“.5”这个是一个“坑”，且python2和python3出来的接口有时候是不一样的，尽量避免使用round()函数吧

'''
    round()函数只有一个参数，不指定位数的时候，返回一个整数，
    而且是最靠近的整数，类似于四舍五入
'''
# 四舍五入，不指定位数，取整
print(round(1.1125))  #>>> 1
'''
    当指定取舍的小数点位数的时候，一般情况也是使用四舍五入的规则，
    但是碰到.5的情况时，
    如果要取舍的位数前的小数是奇数，则直接舍弃，
    如果是偶数则向上取舍。
'''
# 取3位小数，由于3为奇数，则向下“舍”
print("round(1.1135,3)=",round(1.1135,3))  #>>> round(1.1135,3)= 1.113
# 取3位小数，由于2为偶数，则向上“入”
print("round(1.1125,3)=",round(1.1125,3))  #>>> round(1.1125,3)= 1.113

# 无法理解，查阅一些资料是说python会对数据进行截断，没有深究
print("round(2.5)=",round(2.5))  #>>> round(2.5)= 2
print("round(1.5)=",round(1.5))  #>>> round(1.5)= 2

3.1.3，字符串输出

• % s——原格式输出
• %10s——右对齐，占位符10位
• %-10s——左对齐，占位符10位
• %.2s——截取2位字符串
• %10.2s——10位占位符，截取两位字符串

# %s 字符串输出
print('%s'%"1234567890")   #>>> 1234567890
# %10s 右对齐,占10位,不够补位
print('%10s'%'hello')      #>>>     hello
# %-10s 左对齐,占10位,不够补位
print('%-10s'%'hello')     #>>> hello
# %.2s 截取2位
print('%.2s'%'hello')      #>>> he
# %10.2s 取2位,占10位,右对齐,不够补位
print('%10.2s'%'hello')    #>>>         he
# %-10.2s 取2位,占10位,左对齐,不够补位
print('%-10.2s'%'hello')   #>>> he

3.1.4，format () 函数

• 基本用法
  相对基本格式化输出采用‘%’的方法，format()功能更强大，该函数把字符串当成一个模板，通过传入的参数进行格式化，并且使用大括号‘{}’作为特殊字符代替‘%’

1. 不带编号，即“{}”
2. 带数字编号，可调换顺序，即“{1}”、“{2}”
3. 带关键字，即“{a}”、“{tom}”

# 不带编号，即“{}”
print('{} {}'.format('hello','world'))    #>>> hello world
# 带数字编号
print('{0} {1}'.format('hello','world'))  #>>> hello world
# 带数字编号，可以打乱顺序
print('{0} {1} {0}'.format('hello','world'))  #>>> hello world hello
# 带关键字
print('{key1} {key2} {key1}'.format(key1='hello',key2='world'))  #>>> hello world hello
# 处理元组
coord = (0,1)
print('x = {0[0]}; y= {0[1]}'.format(coord))   #>>> x = 0; y= 1
# 处理字典
dict = { 'key1':'value1','key2':'value2'}
print('key1 = {0[key1]} ; key2 = {0[key2]}'.format(dict))  #>>> key1 = value1 ; key2 = value2

• format 用法的变形

# f"xxxx"
# 可在字符串前加f以达到格式化的目的，在{}里加入对象，此为format的另一种形式：
name = 'jack'
age = 18
sex = 'man'
job = "IT"
salary = 9999.99

print(f'my name is {name.capitalize()}.')  #>>> my name is Jack.
print(f'I am {age:*^10} years old.')       #>>> I am ****18**** years old.
print(f'I am a {sex}')                     #>>> I am a man   
print(f'My salary is {salary:10.3f}')      #>>> My salary is   9999.990

• format 进阶用法

1. 进制转换

print( "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(42))
#>>> 'int: 42;  hex: 2a;  oct: 52;  bin: 101010'
# 在前面加“#”，则带进制前缀
print("int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(42))
#>>> 'int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010'

2. 左中右对齐及位数补全

# -- 默认左对齐
print("{} and {}".format("hello","woeld"))     #>>> hello and woeld
# -- 取十位左对齐，取十位右对齐  s可要可不要
print("{:<10s} and {:>10s}".format("hello","world"))   #>>> hello      and      world
print("{:<10} and {:>10}".format("hello","world"))     #>>> hello      and      world
# -- 取十位中间对齐
print("{:^10s} and {:^10s}".format("hello","world"))   #>>>   hello    and   world
# -- 使用’*‘填充
print("{:*^20}".format("hello"))   #>>> *******hello********
# -- 还有’=‘只适用于数字,可用’>‘替代
print('{:0=10}'.format(11))

3. 百分数

# -- 保留两位有效数字,且带‘%‘显示
print('{:.2%}'.format(19/22))    #>>> 86.36%

4. 时间格式

import datetime
date = datetime.datetime(2020,11,30,15,12,00)
print('{:%Y-%m-%d %H:%M:%S}'.format(date))   #>>> 2020-11-30 15:12:00

5. 逗号’,'分割金钱,每1000进位

print('{:,}'.format(1234567890))      #>>> 1,234,567,890

3.5， 格式化转换

• ‘b’ - 二进制。将数字以2为基数进行输出。
• ‘c’ - 字符。在打印之前将整数转换成对应的Unicode字符串。
• ‘d’ - 十进制整数。将数字以10为基数进行输出。
• ‘o’ - 八进制。将数字以8为基数进行输出。
• ‘x’ - 十六进制。将数字以16为基数进行输出，9以上的位数用小写字母。
• ‘e’ - 幂符号。用科学计数法打印数字。用’e’表示幂。
• ‘g’ - 一般格式。将数值以fixed-point格式输出。当数值特别大的时候，用幂形式打印。
• ‘n’ - 数字。当值为整数时和’d’相同，值为浮点数时和’g’相同。不同的是它会根据区域设置插入数字分隔符。
• ‘%’ - 百分数。将数值乘以100然后以fixed-point(‘f’)格式打印，值后面会有一个百分号。

# 'b' - 二进制。将数字以2为基数进行输出。
print('{0:b}'.format(3))    #>>> 11
# 'c' - 字符。在打印之前将整数转换成对应的Unicode字符串。
print('{0:c}'.format(122))   #>>> z
# 'd' - 十进制整数。将数字以10为基数进行输出。
print('{:d}'.format(20))    #>>> 20
# 'o' - 八进制。将数字以8为基数进行输出。
print('{:o}'.format(20))    #>>> 24
# 'x' - 十六进制。将数字以16为基数进行输出，9以上的位数用小写字母。
print('{:x}'.format(20))    #>>> 14
# 'e' - 幂符号。用科学计数法打印数字。用'e'表示幂。
print('{:e}'.format(20))    #>>> 2.000000e+01
# 'g' - 一般格式。将数值以fixed-point格式输出。当数值特别大的时候，用幂形式打印。
print('{:g}'.format(20.1))
# 'n' - 数字。当值为整数时和'd'相同，值为浮点数时和'g'相同。不同的是它会根据区域设置插入数字分隔符。
print('{:n}'.format(20))
# '%' - 百分数。将数值乘以100然后以fixed-point('f')格式打印，值后面会有一个百分号
print('{:%}'.format(20))

4，Python运算符

上一篇 Python 基础（1）.