Python学习——Python基础

二,Python基础

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

今日纲要

    • 二,Python基础
      • 1,编程三步曲
      • 2,Python基础语法
        • 2.1,注释
        • 2.2,标识符
        • 2.3,保留字符
        • 2.4,行和缩进
        • 2.5,常用的基本函数
      • 3,Python变量
        • 3.1, 变量概念
        • 3.2, 变量类型
          • 3.2.1, Python数字
          • 3.2.2, Python字符串
          • 3.2.3, Python列表
          • 3.2.4, Python元组
          • 3.2.5, Python字典
          • 3.2.6, Python集合
        • 3.4, 格式化输出
          • 3.1.1,整数的输出
          • 3.1.2,浮点数输出
          • 3.1.3,字符串输出
          • 3.1.4,format () 函数
        • 3.5, 格式化转换
      • 4,Python运算符
    • 上一篇 [Python 基础(1)](https://blog.csdn.net/weixin_45629612/article/details/110247806).

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 的关键字只包含小写字母。
Python学习——Python基础_第1张图片

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,常用的基本函数
  • 关注函数的使用,不关注实现的细节。
    使用者不必关心实现者是如何实现的。
    Python学习——Python基础_第2张图片
函数 作用/适用性
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灵活的原因之一。

  • 变量在内存中如何存储
    Python学习——Python基础_第3张图片
    改变字符串这类不可变类型的变量,会直接创建新的字符串对象,并且替换掉变量中原来存储的对象的地址。
3.2, 变量类型

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

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

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

  • 不可变数据(3 个):Number(数字)、String(字符串)、Tuple(元组);
  • 可变数据(3 个):List(列表)、Dictionary(字典)、Set(集合)。

空值对象作用示意图
Python学习——Python基础_第4张图片

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开始的,最大范围是字符串开头
    Python学习——Python基础_第5张图片

特点2: 字符串的截取。

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

Python学习——Python基础_第6张图片

实例:
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'
  1. 左中右对齐及位数补全
# -- 默认左对齐
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))
  1. 百分数
# -- 保留两位有效数字,且带‘%‘显示
print('{:.2%}'.format(19/22))    #>>> 86.36%
  1. 时间格式
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
  1. 逗号’,'分割金钱,每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).

你可能感兴趣的:(python)