Python基础入门

Python基础
发布日期:   2022-03-17
文章字数:   2.8k

Life is short, use Python.

1.内置对象、运算符、表达式、关键字

1.1 Python常用内置对象

​ python中一切都是对象！python中的对象有：
​ ◾ 内置对象：可以直接使用
​ ◾ 标准库对象：需要导入之后才能使用
​ ◾ 扩展库对象：需要先安装相应的扩展库然后导入才能使用

1.1.1 数据类型（data type）

数据类型表示数据的性质， 有整数、小数、字符串等类型。Python中的**type()**函数可以用来查看数据类型。

>>> type(10)
<class 'int'>
>>> type(2.718)
<class 'float'>
>>> type("hello")
<class 'str'>
  1. 内置的数据类型有整型、实数、复数。整数类型除了常见的十进制整数，还有如下进制：
  • 二进制，以0b开头，每一位只能是0或1
  • 八进制，以0o开头，每一位只能是0、1、2、3、4、5、6、7这八个数字之一
  • 十六进制，以0x开头，每一位只能是0、1、2、3、4、5、6、7、8、9、a、b、c、d、e、f之一

  1. Python支持任意大的数字

  2. 由于精度问题，对于实数计算会有一定的误差

    >>> 0.4-0.1==0.3 #避免直接比较两个实数是否相等
False
>>> abs(0.4-0.1-0.3)<1e-6 #1e-6:10的-6次方
True

  3. 为了提高可读性，Python 3.6.x及更高版本支持在数字中间位置插入单个下划线

    >>> 1_000_000
1000000

1.1.2 变量（variable）

>>> x = 100 # 整型变量
>>> print(x) # 输出x 
100
>>> y = 3.14
>>> x * y
314.0
>>> type(x * y) #内置函数type()用来查看变量类型
<class 'float'>

>>> x = [1,2,3] # 创建为列表对象x，之前的整型变量x不复存在
>>> print(x)
[1,2,3]
>>> isinstance(x,list) #内置函数isinstance()测试变量是否为指定类型
True
  1. Python是属于“动态类型语言”的编程语言，所谓动态，是指变量的类型是根据情况自动决定的。
  2. Python变量不直接存储值，而是存储值的内存地址或引用，这也是变量类型可以随时改变的原因。
  3. 可以使用中文作为变量名，Python 3.x全面支持中文，中文和英文字母都当作一个字符对待。
  4. 在Python中定义变量名的规范：
    • 以字母或下划线开头
    • 不能有空格或标点符号
    • 不能使用关键字做变量名
    • 对英文字母大小写敏感

1.1.3 字符串

  1. 在python中，只有字符串类型的常量和变量，没有字符常量和变量，单个字符也是字符串
  2. 表示字符串的界定符：单引号、双引号、三单引号、三双引号
>>> x='Life is short'    #单引号
>>> x="Life's pathetic"  #双引号
>>> print(x)
Life's pathetic
>>> x=x+''',let’s pythonic.'''   #连接字符串
>>> x
"Life's pathetic,let’s pythonic."
>>> x*2                          #字符串重复
"Life's pathetic,let’s pythonic.Life's pathetic,let’s pythonic."

1.1.4 运算符与表达式

1.1.5 Python常用内置函数

  1. 使用 dir(__builtins__) 可以查看所有内置函数和内置对象
  2. 使用 help(函数a名) 可查看函数a的用法
  3. python常用内置函数，浅看一下

(1) 类型转换与判断

#1.1 进制转换
>>> bin(123)  #转换为二进制串
'0b1111011'
>>> oct(123)  #转换为八进制串
'0o173'
>>> hex(123)  #转换为十六进制串
'0x7b'

#1.2 float()将其他类型转换为实数，complex()生成复数
>>> float('3')
3.0
>>> complex('inf')   #无穷大，其中inf不区分大小写
(inf+0j)
>>> int('9')         #int(x[,d])返回实数(float),分数(fraction)，高精度实数(decimal)x的整数部分
9
>>> int('110',2)     #或把d进制的字符串x转换为十进制并返回，d默认为十进制
6

#1.3 ord()用来返回单个字符的Unicode码，chr()用来返回Unicode编码对应的字符，str()直接将任意类型的参数转换为字符串
>>> ord('a')          
97
>>> chr(65)
'A'
>>> chr(ord('A')+1)    #Python不允许字符串与数字之间的加法操作
'B'
>>> chr(ord('国')+1)   #支持中文
'图'
>>> str(1234)
'1234'
>>> str([1234])
'[1234]'

#1.3 list(),tuple(),dict(),set()
>>> list(range(5))      #把range对象转换为列表
[0, 1, 2, 3, 4]
>>> tuple(_)            #下划线表示上一次正确的输出结果  
(0, 1, 2, 3, 4)
>>> dict(zip('1234','abcd'))      #创建字典
{'1': 'a', '2': 'b', '3': 'c', '4': 'd'}
>>> set('111222334')    #创建可变集合，自动去除重复
{'1', '4', '2', '3'}

#1.4 eval()用来计算字符串的值，或者实现类型转换
>>> eval('3+5')
8
>>> eval(b'3+5')        #引号前面加b表示字节串
8
>>> eval('09')          #抛出异常，不允许以0开头的数字
   SyntaxError: invalid token
>>> int('09')           
9
>>> list(str([1,2,3]))
['[', '1', ',', ' ', '2', ',', ' ', '3', ']']
>>> eval(str([1,2,3]))   #字符串求值
[1, 2, 3]

#1.5 type() ,isinstance()判断数据类型
>>> type([3])
<class 'list'>
>>> type({3})in (list,tuple,dict)
False
>>> isinstance(3j,(int,float,complex))
True

(2) 最值与求和

max()、min()、sum()分别用于计算列表、元组或其他包含有限个元素的可迭代对象中所有元素最大值、最小值、所有元素之和

#列表推导式，生成包含3个子列表的列表，每个子列表中包含5个介于[1,50]区间的任意整数
>>> lst=[[randint(1,50) for i in range(5)] for j in range(3)]
>>> print(lst)
[[4, 29, 35, 1, 49], [1, 5, 6, 28, 26], [32, 50, 12, 31, 30]]
>>> max(lst,key=sum)                 #返回元素之和最大的子列表
[32, 50, 12, 31, 30]
>>> a=max(lst,key=lambda x:x[1])     #所有子列表中第2个元素最大的子列表
>>> print(a)
[32, 50, 12, 31, 30]
>>> print(a,max(a),min(a),sum(a),sum(a)/len(a))
[32, 50, 12, 31, 30] 50 12 155 31.0

(3) 基本输入/输出

不论输入什么，input()一律作为字符串对待

>>> x=input('please input:')     #input()函数参数表示提示信息
please input:1123
>>> x
'1123'
>>> type(x)
<class 'str'>
>>> int(x)
1123

print(value1,value2,...,sep=' ',end='\n',file=sys.stdout,flush=False)

sep参数用于指定数据之间的分隔符，默认为空格。end参数用于指定每个输出之后的分隔符，默认换行

>>> print(1,2,3,4,sep='\t')
1    2    3    4
>>> for i in range(10):      #修改end参数，每个输出之后不换行
    print(i,end=' ')

0 1 2 3 4 5 6 7 8 9

(4) 排序与逆序

sorted()可以对列表、元组、字典、集合或其他可迭代对象进行排序并返回新列表，支持使用key参数指定排序规则

>>> x=list(range(11))
>>> import random
>>> random.shuffle(x)               #shuffle()用来随机打乱顺序
>>> x
[1, 10, 8, 5, 6, 2, 9, 0, 4, 7, 3]
>>> sorted(x)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  #sorted()默认升序排列，参数reverse=false
>>> sorted(x,key=lambda item:len(str(item)),reverse=True)  #转换为字符串后按字符串中的字符个数进行降序排列
[10, 1, 8, 5, 6, 2, 9, 0, 4, 7, 3]
>>> sorted(x,key=str)
[0, 1, 10, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x                               #不影响原来列表的元素顺序
[1, 10, 8, 5, 6, 2, 9, 0, 4, 7, 3]
>>> x=['aaa','bc','d','bbbb']
>>> sorted(x,key=lambda item:(len(item),item))             #先按长度排序，长度一样的正常排序
['d', 'bc', 'aaa', 'bbbb']

reversed()可以对可迭代对象（生成器对象和具有惰性求值特性的zip、map、filter、enumerate等类似对象除外）进行翻转（首尾交换）并返回可迭代的reversed对象

>>> list(reversed(x))             #reversed对象是可迭代的
['bbbb', 'd', 'bc', 'aaa']

(5) 枚举与迭代

enumerate()函数用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组。使用时，即可以把enumerate对象转换为列表、元组、集合，也可以使用for循环直接遍历其中元素。

>>> list(enumerate('abcd'))                  #枚举字符串中的元素
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> list(enumerate(['Python','WuLa']))       #枚举列表中的元素
[(0, 'Python'), (1, 'WuLa')]
>>> for index,value in enumerate(range(3,9)):
    print((index,value),end=' ')

(0, 3) (1, 4) (2, 5) (3, 6) (4, 7) (5, 8)

(6) map()函数

map()把一个函数func依次映射到序列的每个元素上，并返回一个可迭代的map对象作为结果，map对象中每个元素是原序列中元素经过函数func处理后的结果，map()不对原序列做任何修改

>>> list(map(str,range(5)))     #把列表中元素转换为字符串
['0', '1', '2', '3', '4']
>>> def add3(v):              
    return v+5
>>> list(map(add3,range(10)))    #把单参函数add3()映射到一个序列上的所有元素
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

>>> def add(x,y):               #接收两个参数的函数
    return x+y
>>> list(map(add,range(5),range(5,10)))   #把双参数函数映射到两个序列上
[5, 7, 9, 11, 13]
>>> list(map(lambda x,y:x+y,range(5),range(5,10)))
[5, 7, 9, 11, 13]

>>> x=232412134141341
>>> list(map(int,str(x)))      #提取整数x每位上的数字
[2, 3, 2, 4, 1, 2, 1, 3, 4, 1, 4, 1, 3, 4, 1]

(7) reduce()函数

标准库functools中的函数reduce()可将一个双参数函数以迭代累计的方式从左到右依次作用到一个序列或迭代器对象的所有元素上，并且允许制定一个初始值。

>>> from functools import reduce
>>> reduce(lambda x,y:x+y,[1,2,3,4,5])  #计算过程：(((1+2)+3)+4)+5
15

(8) filter()函数

filter()将一个单参数函数func作用到一个序列上，返回该序列中满足使func返回值为True的元素组成的filter元素，若func为None，则返回序列中等价于True的函数。

>>> seq=['python','zx11','???']
>>> def func(x):
    return x.isalnum()            #isalnum()使字符串的方法，用于测试x是否为字母或数字

>>> filter(func,seq)            #返回filter对象
<filter object at 0x00000208298D64A8>
>>> list(filter(func,seq))        #将filter对象转换为列表
['python', 'zx11']
>>> seq
['python', 'zx11', '???']        #不对原列表做任何修改
>>> list(filter(None,[1,0,3,'',True,False]))    #func为None，则返回序列中等价于True的函数
[1, 3, True]

(9) range()函数

range([start,] stop [,step])返回具有惰性求值特点的range对象，包含左闭右开区间[start,stop）内以step为步长的整数，参数start默认为0，step默认为1。

>>> range(5)            #start默认为0，step默认为1
range(0, 5)
>>> list(_)
[0, 1, 2, 3, 4]
>>> list(range(1,10,2))#指定起始值和步长
[1, 3, 5, 7, 9]
>>> list(range(9,0,-2))#步长为负数时，start应比end大
[9, 7, 5, 3, 1]
>>> for i in range(4): #循环4次
    print(3,end=" ")
    
3 3 3 3

(10) zip()函数

zip()用来把多个可迭代对象中对应位置上的元素压缩在一起，返回一个可迭代的zip()对象

>>> x=zip('abcd',[1,2,3])        #压缩字符串和列表
>>> list(x)                        #zip对象只能遍历一次，访问过的元素就不存在了，enumerate、filter、map对象以及生成器对象也有这个特点
[('a', 1), ('b', 2), ('c', 3)]
>>> list(x)
[]

>>> list(zip('abcd'))            #对1个序列也能压缩
[('a',), ('b',), ('c',), ('d',)]
>>> list(zip('123','abc',',./'))#压缩三个序列
[('1', 'a', ','), ('2', 'b', '.'), ('3', 'c', '/')]
>>> for item in zip('abcd',range(3)):    #zip对象是可迭代的
    print(item,end=' ')
    
('a', 0) ('b', 1) ('c', 2)
>>> key_list=['name','age']
>>> val_list=['Estrella',20]
>>> dict(zip(key_list,val_list))    #两个序列打包成一个字典
{'name': 'Estrella', 'age': 20}

未完待续🌹🌹🌹

😊文章作者：Estrella

🔗文章链接：https://starryzx.github.io/2022/03/17/python-ji-chu-ru-men/

© 版权声明：本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自Estrella

Python基础
评论
  目录