笔记来源https://www.bilibili.com/video/BV1PE411c71h?p=2.
# 单行注释
'''
这是多行注释,使用单引号。
这是多行注释,使用单引号。
这是多行注释,使用单引号。
'''
"""
这是多行注释,使用双引号。
这是多行注释,使用双引号。
这是多行注释,使用双引号。
"""
在 Python 里,标识符由字母、数字、下划线组成。但不能以数字开头。
Python 中的标识符是区分大小写的。
命名尽量见名知意,会影响到程序的可读性。
以下划线开头的标识符是有特殊意义的。
以单下划线开头 _foo 的代表不能直接访问的类属性,需通过 类提供的接口进行访问,不能用 from xxx import * 而导入。
以双下划线开头的 _ _ foo 代表类的私有成员,以双下划线开头和结尾的 _ _ foo _ _ 代表 Python 里特殊方法专用的标识,如 _ _ init _ _ () 代表类的构造函数。
下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数,或任何其他标识符名称。
学习 Python 与其他语言最大的区别就是,Python 的代码块不使用大括号 {} 来控制类,函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。
缩进的空白数量是可变的,但是所有代码块语句必须包含相同的缩进空白数量,这个必须严格执行。
以下实例缩进为四个空格:
if True:
print(“True”)
else:
print("False")
print("没有严格缩进")
print("在执行时会报错IndentationError: unindent does not match any outer indentation level")
print(" a"); print(b)
函数 | 作用/适用性 |
---|---|
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'>
定义:关联一个对象的标识符。变量名对应真实的内存地址,变量名是为了方便人类记忆。
命名规则:必须是字母或下滑线开头,后面跟字母,数字,下滑线。建议小写,多个单词以下划线隔开,且见名知意。
赋值:创建一个变量或改变一个变量绑定的数据。每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。
语法:
变量 = 表达式
变量名 = 数据
变量名1=.... = 变量名n = 数据 #同时为多个变量赋值
变量名1,变量名2 = 数据1,数据2 #为多个变量指定多个值,根据顺序分配
python的变量是没有类型的,被创建后才能明确。这也是python灵活的原因之一。
Python中6个标准数据类型,以及空值对象 None.
Python3 的六个标准数据类型中:
作用:用于存储数值。
定义:当你指定一个值时,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 |
进制问题
>>> number = 0b0101 # 二进制
>>> number
5
>>> number = 0o37 # 八进制
>>> number
31
>>> number = 0xA0F # 十六进制
>>> number
2575
python数字类型转换
python中内置了很多用于数据类型之间转换的函数,你只需要将数据类型作为函数名即可。
>>> 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的平方根 |
作用:表示文本。
定义:字符串或串(string)是由数字,数字,下划线组成的一串字符。
s = "a1a2...an" #n>=0
特点1. 字符串列表的两种取值顺序,如下图:
特点2: 字符串的截取。
实例:
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!
作用: 列表可以完成大多数(有序)集合类的数据结构的实现。
定义:由一系列变量组成的可变序列容器 。
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
特点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']
列表的操作
作用:相当于只读列表。
定义: 元组用 () 标识,内部元素用逗号隔开。
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')
作用:字典可以完成大多数(无序)集合类的数据结构的实现。
定义: 字典用"{ }"标识。字典由索引(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']
# %o —— oct 八进制
print('%o' % 20) #>>> 24
# %d —— dec 十进制
print('%d' % 20) #>>> 20
# %x —— hex 十六进制
print('%x' % 20) #>>> 14
(1)格式化输出
# %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()函数只有一个参数,不指定位数的时候,返回一个整数,
而且是最靠近的整数,类似于四舍五入
'''
# 四舍五入,不指定位数,取整
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
# %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
# 不带编号,即“{}”
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
# 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
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'
# -- 默认左对齐
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))
# -- 保留两位有效数字,且带‘%‘显示
print('{:.2%}'.format(19/22)) #>>> 86.36%
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
print('{:,}'.format(1234567890)) #>>> 1,234,567,890
# '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))