python学习——基本语法知识

python基本语法知识

(一) 基本数据类型

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

一、Number(数字)

  1. 利用isinstance 和 type判断变量所指的对象类型。

区别:
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。

 class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> isinstance(A(), A)
True
>>> type(A()) == A 
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False
  1. 数值的除法包含两个运算符:/ 返回一个浮点数,// 返回一个整数。
>>> 1/3
0.3333333333333333
>>> 1//3
0
>>> 8/3
2.6666666666666665
>>> 8//3
2
  1. 在混合计算时,Python会把整型转换成为浮点数。
>>> 1+2.0
3.0
>>> 1+2
3

数学函数

在这里插入图片描述

随机数函数

在这里插入图片描述

三角函数

在这里插入图片描述

数字常量

  • pi 数学常量 pi(圆周率,一般以π来表示)
  • e 数学常量 e,e即自然常数(自然常数)。

*函数具体使用方法详情看:https://www.runoob.com/python3/python3-number.html

二、String(字符串)

  1. 使用引号( ’ 或 " )来创建字符串。
  2. 字符串截取语法:变量[头下标:尾下标] 从前面索引以0为开始值 从后面索引以-1为末尾的开始位置。
str='yyqxmman'
>>> print(str)
yyqxmman
>>> print(str[0:-1])
yyqxmma
>>> print(str[2:5])
qxm
>>> print(str[2:-2])
qxmm
>>> print(str[2:])
qxmman
>>> print(str *2)
yyqxmmanyyqxmman
>>> print(str+"love")
yyqxmmanlove

2.Python 使用反斜杠 \ 转义特殊字符,如果你不想让反斜杠发生转义,可以在字符串前面添加一个 r,表示原始字符串:

>>> print('yy\nqx')
yy
qx
>>> print(r'yy\nqx')
yy\nqx
  1. Python 无单字符类型,一个字符就是长度为1的字符串。与 C 字符串不同的是,Python 字符串不能被改变。向一个索引位置赋值,比如word[0] = 'm’会导致错误。
>>> word = 'yyqxmman'
>>> print(word[0],word[5])
y m
>>> print(word[-1],word[-8])
n y
>>> word[0]='m'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
  1. Python三引号
    允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符。
errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (  
login VARCHAR(8), 
uid INTEGER,
prid INTEGER)
''')
  1. f-string
    f-string 格式化字符串以 f 开头,后面跟着字符串,字符串中的表达式用大括号 {} 包起来,它会将变量或表达式计算后的值替换进去。
>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
'Hello Runoob'
>>> f'{1+2}'         # 使用表达式
'3'

>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'
  1. 字符串内建函数
  • capitalize() 将字符串的第一个字符转换为大写
  • center(width, fillchar) 返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格。
    *还有很多,详见:https://www.runoob.com/python3/python3-string.html

三、List(列表)

  1. 序列中的每个值都有对应的位置值,称之为索引,第一个索引是 0,第二个索引是 1,依此类推。列表和元组都是序列
  2. 列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
  3. 列表截取语法格式(与字符串相同)
    变量[头下标:尾下标]
>>> list = ['yyqx',1128,11.28,'mman',1.028]
>>> tinylist = [123,'lalala']
>>> print(list)
['yyqx', 1128, 11.28, 'mman', 1.028]
>>> print(list[0])
yyqx
>>> print(list[0:4])
['yyqx', 1128, 11.28, 'mman']
>>> print(list[2:-1])
[11.28, 'mman']
>>> print(list*2)
['yyqx', 1128, 11.28, 'mman', 1.028, 'yyqx', 1128, 11.28, 'mman', 1.028]
>>> print(list+tinylist)
['yyqx', 1128, 11.28, 'mman', 1.028, 123, 'lalala']
  1. 不同于Python 字符串不能被改变,列表中的元素是可以改变的。
>>> a=[1,2,3,4,5]
>>> a[0]=9
>>> a[2:4]=[10,11]
>>> a
[9, 2, 10, 11, 5]
>>> a[2:4]=[]
>>> a
[9, 2, 5]
  1. list还有许多方法,类似于append(),pop()等。
    5.Python 列表截取可以接收第三个参数,参数作用是截取的步长,如果第三个参数为负数表示逆向读取。
def reverseWords(input):
     
    # 通过空格将字符串分隔符,把各个单词分隔为列表
    inputWords = input.split(" ")
 
    # 翻转字符串
    # 假设列表 list = [1,2,3,4],  
    # list[0]=1, list[1]=2 ,而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空,表示移动到列表末尾
    # 第三个参数为步长,-1 表示逆向
    inputWords=inputWords[-1::-1]
 
    # 重新组合字符串
    output = ' '.join(inputWords)
     
    return output
 
if __name__ == "__main__":
    input = 'I like runoob very much'
    rw = reverseWords(input)
    print(rw)

输出:much very runoob like I

  1. 列表函数以及方法
  • len() 列表元素个数
  • max() 列表元素最大值
  • min() 列表元素最小值
  • list() 将元组转换为列表
  • list.append(obj) 在列表末尾添加新的对象
    等等:https://www.runoob.com/python3/python3-list.html

四、Tuple(元组)

1.元组(tuple)与列表类似,不同之处在于元组的元素不能修改元组写在小括号 () 里,元素之间用逗号隔开,列表使用方括号【】。与列表相同的是元组中的元素类型也可以不相同。
元组与字符串类似,可以被索引且下标索引从0开始,-1 为从末尾开始的位置。也可以进行截取(看上面,这里不再赘述)。
可以把字符串看作一种特殊的元组。

>>> tuple=('yyqx',1128,1,28,'mman',123)
>>> tinytuple = (123,'yyqx')
>>> print(tuple)
('yyqx', 1128, 1, 28, 'mman', 123)
>>> print(tuple[0])
yyqx
>>> print(tuple[0:4])
('yyqx', 1128, 1, 28)
>>> print(tuple[2:-1])
(1, 28, 'mman')
>>> print(tuple*2)
('yyqx', 1128, 1, 28, 'mman', 123, 'yyqx', 1128, 1, 28, 'mman', 123)
>>> print(tuple+tinytuple)
('yyqx', 1128, 1, 28, 'mman', 123, 123, 'yyqx')

2.元组与字符串一样,不可修改其中元素。但元组中可包含可改变的list列表。

>>> tuple[0]='lalalal'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> tup=([1,2,3,4],1,'yyqx')
>>> print(tup[0])
[1, 2, 3, 4]

3.构造包含 0 个或 1 个元素的元组比较特殊,所以有一些额外的语法规则:

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素,需要在元素后添加逗号

五、Set(集合)

  1. 集合(set)是由一个或数个形态各异的大小整体组成的,构成集合的事物或对象称作元素或是成员。集合(set)是一个无序的不重复元素序列。基本功能是进行成员关系测试和删除重复元素。可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
parame = {value01,value02,...}
或者
set(value)
  1. 集合中重复的元素会被自动删除,同时集合可以进行成员测试,测试元素是否在集合中
#!/usr/bin/python3

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu','Taobao'}

print(sites)   # 输出集合,重复的元素被自动去掉

# 成员测试
if 'Runoob' in sites :
    print('Runoob 在集合中')
else :
    print('Runoob 不在集合中')

输出:
{‘Baidu’, ‘Zhihu’, ‘Facebook’, ‘Google’, ‘Runoob’, ‘Taobao’}
Runoob 在集合中

  1. 使用set(value)创建集合,a = set(‘abracadabra’)中每个字母为集合元素。
a = set('abracadabra')
>>> b = set('alacazam')
>>> print(a)  #自动删除重复元素
{'r', 'd', 'a', 'c', 'b'}
>>> print(a-b) #a和b差集
{'b', 'r', 'd'}
>>> print(a|b) #a和b并集
{'r', 'z', 'd', 'l', 'a', 'c', 'm', 'b'}
>>> print(a&b) #a和b交集
{'c', 'a'}
>>> print(a^b) #a和b中不同时存在的元素
{'m', 'b', 'r', 'z', 'd', 'l'}
  1. 集合内置方法
    add() 使用set.add(elem)添加元素
    clear()
    等:https://www.runoob.com/python3/python3-set.html

六、Dictionary(字典)

  1. 字典(dictionary)是Python中一个非常有用的内置数据类型。列表是有序的对象集合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
    字典是一种映射类型,字典用 { } 标识,它是一个无序的 键(key) : 值(value) 的集合。
    键(key)必须使用不可变类型。
    在同一个字典中,键(key)必须是唯一的。
#第一种构造字典方式
dict={}
>>> dict['one'] = "yyqx"
>>> dict[2]     = "2mman"

>>> print (dict['one'])#输出键为 'one' 的值
yyqx
>>> print (dict[2])#输出键为 2 的值
2mman
#第二种构造字典方式
>>> tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
>>> print (tinydict)
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
>>> print (dict)
{'one': 'yyqx', 2: '2mman'}
>>> print (tinydict.keys())#输出所有键
dict_keys(['name', 'code', 'site'])
>>> print (tinydict.values())#输出所有值
dict_values(['runoob', 1, 'www.runoob.com'])
  1. 构造函数 dict() 可以直接从键值对序列中构建字典如下:
>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Runoob': 1, 'Google': 2, 'Taobao': 3}

>>> {x: x**2 for x in (2, 4, 6)}#字典推导式
{2: 4, 4: 16, 6: 36}

>>> dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}

字典是一种映射类型,它的元素是键值对。字典的关键字(key)必须为不可变类型,且不能重复。创建空字典使用 { }。

  1. 字典内置函数和方法:
  • len(dict) 计算字典元素个数,即键的总数。
  • str(dict) 输出字典,可以打印的字符串表示。
  • type(variable) 返回输入的变量类型,如果变量是字典就返回字典类型。
  • dict.clear() 删除字典内所有元素
  • dict.copy() 返回一个字典的浅复制
    等等:https://www.runoob.com/python3/python3-dictionary.html

总结

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

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

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

(二)数据类型转换

  • 隐式类型转换(自动)
  • 显示类型转换 (类型函数)

一、隐式类型转换

Python 会自动将一种数据类型转换为另一种数据类型,不需要我们去干预。

对两种不同类型的数据进行运算,较低数据类型(整数)就会转换为较高数据类型(浮点数)以避免数据丢失。

 int=123
>>> flo=1.23
>>> new=int+flo
>>> new
124.23
>>> print("datatype of int:",type(int))
datatype of int: <class 'int'>
>>> print("datatype of flo:",type(flo))
datatype of flo: <class 'float'>
>>> print("datatype of new:",type(new))
datatype of new: <class 'float'>

二、显式类型转换

使用 int()、float()、str() 等预定义函数来执行显式类型转换。

  • int() 强制转换为整型
  • float() 强制转换为浮点型
  • str() 强制转换为字符串类型
  • repr()强制转换为表达式字符串
  • eval()计算在字符串中的有效Python表达式,并返回一个对象
  • tuple()转换为一个元组
  • list()转换为一个列表
  • set()转换为可变集合
  • dict()创建字典
  • frozenset()转变为不可变集合
  • chr()将整数转变为字符
  • ord()字符转换为整数
  • hex()整数转换为十六进制字符串
  • oct()整数转换为八进制字符串

(三)python推导式

  • 列表(list)推导式
  • 字典(dict)推导式
  • 集合(set)推导式
  • 元组(tuple)推导式

一、列表(list)推导式

  1. [表达式 for 变量 in 列表]
    [out_exp_res for out_exp in input_list]

  2. [表达式 for 变量 in 列表 if 条件]
    [out_exp_res for out_exp in input_list if condition]

>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
#过滤长度小于等于3的字符串列表,并将剩下的转换成大写字母后输出
>>> new_names = [name.upper()for name in names if len(name)>3]
>>> new_names
['ALICE', 'JERRY', 'WENDY', 'SMITH']

二、字典推导式

  1. { key_expr: value_expr for value in collection }
  2. { key_expr: value_expr for value in collection if condition }

eg1:使用列表中字符串值为键,各字符串的长度为值,组成字典

>>> listdemo = ['Google','Runoob', 'Taobao']
>>> newdict = {key:len(key) for key in listdemo}
>>> newdict
{'Google': 6, 'Runoob': 6, 'Taobao': 6}

eg2:提供三个数字,以三个数字为键,三个数字的平方为值来创建字典

>>> dic = {x: x**2 for x in (2, 4, 6)}
>>> dic
{2: 4, 4: 16, 6: 36}

三、集合推导式

  1. { expression for item in Sequence }
  2. { expression for item in Sequence if conditional }

eg1:数字 1,2,3 的平方数

>>> setnew = {i**2 for i in (1,2,3)}
>>> setnew
{1, 4, 9}

eg2:判断不是 abc 的字母

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}

四、元组推导式

元组推导式和列表推导式的用法也完全相同,只是元组推导式是用 () 圆括号将各部分括起来,而列表推导式用的是中括号 [],另外元组推导式返回的结果是一个生成器对象。

>>> a = (x for x in range(1,10))#返回生成器对象
>>> a
<generator object <genexpr> at 0x01358E70>
>>> tuple(a)
(1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> a = [x for x in range(1,10)]#列表推导式
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值