您的位置: 首页  >  IT文章  >  Python基础之运算符及数据类型(列表及元组)

Python基础之运算符及数据类型(列表及元组)

分类: IT文章 • 2023-11-03 12:39:06
  • 运算符
  • 数据类型
  • 字符串类型及操作
  • 切片
  • 列表类型及操作
  • 元祖类型及操作

0x01 运算符

  • 算术运算符
+         # 加  --> 两对象相加  
-          # 减  --> 1、负数  2、两个数相减
*          # 乘  --> 1、两个数相乘 2、重复前面字符若干次
/          # 除  --> 两数相除 
%        # 取模      --> 返回两数相除后的"余数"
//         # 取整除   --> 返回两数相除后，"商"的整数部分
  • 比较运算
==      # 等于       ---> 两个对象是否相等
!=       # 不等于    ---> 两个对象不相等
<>      # 不等于    ---> 两个对象不相等
>        # 大于        ---> 左边大于右边
<        # 小于        ---> 左边小于右边，返回1为真(True)；返回0为假(False)
>=      # 大于等于    ---> 左边大于等于右边
<=      # 小于等于    ---> 左边小于等于右边
  • 赋值运算
=        # 赋值
+=      # 加法赋值运算
-=       # 减法赋值运算
*=       # 乘法赋值运算
/=       # 除法赋值运算
%=     # 取模赋值运算
//=      # 取整除赋值运算
  • 位运算
&       # 与
|        # 或
^       # 异或
~       # 取反
<<     # 左移动
>>     # 右移动
  • 逻辑运算
and    # 布尔"与"
or       # 布尔"或"
not     # 布尔"非"
  • 成员运算
in        # 若在指定序列中找到值。返回True，否则返回False。
not in  # 若在指定序列中没找到值。返回True，否则返回False。
  • 身份运算
is        # 判断两个标识符，是不是引用一个对象
is not  # 判断两个标识符，是不是引用不同对象

0x02 数据类型

Python中，能直接处理的数据类型为: 数值型、字符串型、列表型、元组型、字典型

  • 数值类型
    分类：整型、浮点型、长整型、复数

2.1 整型
范围: 2**32(2的31次方个正和2的31次方的个负数),包含正数和负数
查看数据类型方法: type()

  • 定义字符串
>>> res = "Hello World!"
>>> type(res)
<class 'str'>
>>> date = 20
>>> type(date)
<class 'int'>

2.2 浮点型
带小数点的数，在进行计算时，位数会进行四舍五入

  • 定义浮点数
>>> a = 12.3
>>> type(a)
<class 'float'>
>>> b = 15.7
>>> type(b)
<class 'float'>

2.3 长整型
L 或 l 表示，在python3内，已被取消

>>> a = 121211212122222222222222222222222222222222222222222222222222222222222
>>> type(a)
<class 'int'>            # python3内，已取消

2.4 复数
j 标识
复数一般用于科学计算，一般不会使用

>>> type(341j)
<class 'complex'>

2.5 类型转换

  • 字符串数值转换为浮点型
>>> num = '12'
>>> type(num)
<type 'str'>
>>> float(num)
12.0
  • 字符串转换为整形
>>> num = '18'
>>> type(num)
<type 'str'>
>>> num1 = int(num)
>>> type(num1)
<type 'int'>
>>> num1
18
  • 整形转换为浮点型
>>> num = 20
>>> type(num)
<type 'int'>
>>> num1 = float(num)
>>> num1
20.0
>>> type(num1)
<type 'float'>
  • 浮点型 转换为整形
>>> num = 22.33
>>> type(num)
<type 'float'>
>>> num1 = int(num)
>>> type(num1)
<type 'int'>
>>> num1
22
  • round() 返回浮点数x的四舍五入值

格式：

round( x [, n]  )

示例:

>>> round(4.567, 2)
4.57
>>> type(a)
<type 'float'>

0x03 字符串类型及操作

3.1 以 单引号 ( ' ) 或 双引号 ( “ ) 括起来的任意对象

3.2 定义字符串：单引号，双引号，三引号

  • 字符串定义
str='This is string'
str="This is string"
str='''This is string'''

PS:
三个引号 ( """ )可以是多行注释，但不能单双混合

3.3 字符串方法

  • 查找
    功能：找到sub在str中的位置，如果找到返回index（匹配到第一个），找不到返回-1
    用法：str. find(sub,start=None,end=None)
>>> name = "python"
>>> name.find(3)
>>> name.find("t")
2
  • 替换
    功能：字符串的替换,把src替换为dst，counter为替换几次
    用法：str.replice('src','dst',counter=None)
>>> name = 'Hello python'
>>> name.replice('p','P')
>>> name
Hello Python
  • 去除字符串前后空格
    功能：去除两边的string,默认是移除空格换行及制表符
    用法：str.strip('string')
>>> str = ' Python '
>>> str.strip()
'Python'
  • 字符串连接
    功能：连接，用于把可迭代对象的每个元素用 什么 连接起来，可迭代对象的元素必须是str
    用法：'分隔符'.join(iterable)
>>> str = 'Hello Python'
>>> '_'.join(str)
'H_e_l_l_o_ _P_y_t_h_o_n'
  • 分割字符串
    功能：把字符串默认从左开始对象使用split进行分割，默认会对所有分割符进行分割，num可以指定分隔符的个数
    用法：str.split('split',num=None)
>>> str = 'Hello Python'
>>> str.split('y')
['Hello P', 'thon']
  • 格式化字符串
    功能：格式化字符串，位置占位符为{0},{1}
    用法：str.format()
>>> print('Hello {0}'.format('World'))
Hello World

PS：
采用命名占位符{name},{age},赋值时候需要 name=Mr.Chow,age=18

0x04 切片操作

4.1 字符串是一个序列，可以通过 索引 和 切片 操作
4.2 原则： 前开后闭

  • 从第0个开始截取2个字符，其中0可以省略
In [1]: a='abcd'
In [2]: a[0:2]
Out[3]: 'ab'
  • 默认是从左往右（前往后），带减号，表示从右往左（后往前），-1表示最后一个字符(a='abcd',-1的值是d，也就是3，顾a[:-1]，就等于a[0:3])
In [4]: a='abcd'
In [5]: a[:-1]
Out[6]: 'abc'
  • 从1开始截取到最后
In [7]: a='abcd'
In [8]: a[1:]
Out[9]: 'bcd'
  • 步长为2，表示从0开始步长为2，(取0,2,4,6)
In [10]: a='abcd'
In [11]: a[::2]
Out[12]: 'aceg'
  • 表示倒着取，从倒数第五个取到倒数第一个（不包含倒数第一，要想取可以使用a[-5:]）
In [13]: a
Out[14]: 'abcdefg'
In [15]: a[-5:-1]
Out[16]: 'cdef'
  • 从0开始取到第5个，步长为1，步长为2
In [17]: a
Out[18]: 'abcdefg'
In [19]: a[0:5:1]
Out[20]: 'abcde'
In [21]: a[0:5:2]
Out[22]: 'ace'
  • 从后往前取，步长为-1，表示每次倒着取1个，由于没有指定结尾，默认到最后，所以就把数字逆了过来
In [23]: a
Out[24]: 'abcdefg'
In [25]: a[-1::-1]
Out[26]: 'gfedcba'
  • 表示先每隔2个取出来，然后从头开始取2个
In [27]: a
Out[28]: 'abcdefg'
In [29]: a[::2][:2]
Out[30]: 'ac'

0x05 列表类型及操作

  • 定义
  • 方法
  • 分片
  • 定义

5.1 关键字 --> list，有序集合， 数据可变，[]标识，元素间逗号分隔

  • 创建列表
list1 = []              # 创建空列表  
list2 = list()         # 工厂函数，调用list()内部函数给list2进行赋值
  • 创建有值列表
list3 = [1, 'list', True]
  • 复杂列表
str = 100
list = ['Chow', str, (11, 43), False, ['Robin', 'Python'], {name: 'Chow', age: 18}]
print(list)
print(type(list))
len(list)
  • 方法操作
  • 方法：
append              # 追加  
remove              # 删除指定元素  
pop                    # 删除列表最后一位或指定元素，有返回值  
reverse              # 反转  
insert                 # 数据插入，根据元素下标插入  
sort                    # 排序
  • append(追加)
>>> list = [11, 22, 33, 10, 'aa', True]
>>> list.append(100)
>>> list
[11, 22, 33, 10, 'aa', True, 100]
  • remove(移除指定元素)
list = [11, 22, 33, 10, 'aa', True]
list.remove(33)
print(list)
[11, 22, 10, 'aa', True]
  • pop(删除列表最后一位或指定元素)
list = [11, 22, 33, 10, 'aa', True]
list.pop(-1)
list.pop(0)
print(list)
[22, 33, 10, 'aa']
  • del(删除指定元素)
list = [11, 22, 33, 10, 'aa', True]
del list[0]
print(list)
[22, 33, 10, 'aa', True]
  • reverse(反转)
list = [11, 22, 33, 10, 'aa', True]
list.reverse()
print(list)
[True, 'aa', 10, 33, 22, 11]
  • insert(插入)
list = [11, 22, 33, 10, 'aa', True]
list.insert(2, 'Python')
print(list)
[11, 22, 'Python', 33, 10, 'aa', True]
  • sort(排序)
list = [11, 22, 33, 10, 200, 3]
list.sort()
print(list)
[3, 10, 11, 22, 33, 200]
  • extend(扩张两个列表)
list1 = [11, 22, 33, 10, 200, 3]
list2 = ["aa", 'bb', 'cc']
list1.extend(list2)
print(list1)
[11, 22, 33, 10, 200, 3, 'aa', 'bb', 'cc']
  • 列表循环添加元素
a = list()
for i in range(1, 10):
    a.append(i)

print(a)

[1, 2, 3, 4, 5, 6, 7, 8, 9]
  • 分片
    < 待后期完善 >

0x06 元组类型及操作

  • 概念
  • 特点
  • 定义元祖
  • 操作方法
  • 概念

6.1 标识 () , 逗号 进行分割。是列表的扩展
6.2 不可变类型

  • 特点

6.3 元组值不可改变
6.4 通常用来接收函数的返回值
6.5 可以同时储存不同类型的数据，也可以引用其它元组

  • 定义元祖
tuple1 = (11, 22, 33)
type(tuple1)
print(tuple1)
(11, 22, 33)

tuple1 = (11,)
type(tuple1)
print(tuple1)
(11,)

6.6 元祖引用

tuple1 = (11, 22, 33)
tuple2 = ('aa', 'bb', 'cc', tuple1)
type(tuple2)
print(tuple2)
('aa', 'bb', 'cc', (11, 22, 33))

6.7 引用其它元祖内的指定下标元素

tuple1 = (11, 22, 33)
tuple2 = ('aa', 'bb', 'cc', tuple1[2])
print(tuple2)
('aa', 'bb', 'cc', 33)
  • 元祖方法操作
    6.8 a.count()  统计value在元组中出现的次数，不存在返回0
>>> a = (30, 4, 2, 11, 11, '11', 14, 11)
>>> a.count(11)
3
  • index() 用来返回值在元组中的索引下标，若值不存在，则会报错。如果有多个，默认返回第一个（可以指定从哪个索引开始查找到某个索引)
>>> a = ('11', '22', '33', '41')
>>> a.index('22')
1

>>> a = ('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')
>>> a.index('a', 5, 7)
6

相关推荐