TOC

python的运算符

算数运算符：

运算符

描述

实例

+

加 - 两个对象相加

a + b

-

减 - 得到负数或是一个数减去另一个数

a - b 输出结果 -10

*

乘 - 两个数相乘或是返回一个被重复若干次的字符串

a * b 输出结果 200

/

除 - x除以y

b / a 输出结果 2

//

取整除 - 返回商的整数部分

9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

%

取余 - 返回除法的余数

b % a 输出结果 0

**

幂 - 返回x的y次幂

a**b 为10的2次方， 输出结果100

赋值运算符：

运算符

描述

实例

==

等于 - 比较对象是否相等

(a == b) 返回 False。

!=

不等于 - 比较两个对象是否不相等

(a != b) 返回 true.

<>

不等于 - 比较两个对象是否不相等

(a <> b) 返回 true。这个运算符类似 != 。

>

大于 - 返回x是否大于y

(a > b) 返回 False。

<

小于 - 返回x是否小于y。

所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。

>=

大于等于 - 返回x是否大于等于y。

(a >= b) 返回 False。

<=

小于等于 - 返回x是否小于等于y。

(a <= b) 返回 true。

赋值运算符

运算符

描述

实例

=

简单的赋值运算符

c = a + b 将 a + b 的运算结果赋值为 c

+=

加法赋值运算符

c += a 等效于 c = c + a

-=

减法赋值运算符

c -= a 等效于 c = c - a

*=

乘法赋值运算符

c = a 等效于 c = c a

/=

除法赋值运算符

c /= a 等效于 c = c / a

%=

取模赋值运算符

c %= a 等效于 c = c % a

**=

幂赋值运算符

c **= a 等效于 c = c ** a

//=

取整除赋值运算符

c //= a 等效于 c = c // a

逻辑运算符

运算符

逻辑表达式

描述

实例

and

x and y

布尔”与” - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。

(a and b) 返回 20。

or

x or y

布尔”或”- 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。

(a or b) 返回 10。

not

not x

布尔”非” - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

not(a and b) 返回 False

标准数据类型

在内存中存储的数据可以有多种类型。
 Python 定义了一些标准类型，用于存储各种类型的数据。
 Python有五个标准的数据类型：
 Numbers（数字）
 String（字符串）
 List（列表）
 Tuple（元组）
 Dictionary（字典）
-------------------------------------------------------------------------
#! /usr/bin/env python
# -*- coding: utf-8 -*-
"""
-------------------------------------------------
 Time      ：2018/03/28  22:54
 Author    : Long
 File Name ：test.py
-------------------------------------------------
"""
i = 10
s = "s"
b = True
f = 1.1
l = [1,2,3]
t = (1,2,3)
d = {"a":4, "b":2}
print("整数。{}".format(type(i)))
print("字符串。{}".format(type(s)))
print("布尔型。{}".format(type(b)))
print("浮点数。{}".format(type(f)))
print("列表。{}".format(type(l)))
print("元祖。{}".format(type(t)))
print("字典。{}".format(type(d)))

整数。<class 'int'>
字符串。<class 'str'>
布尔型。<class 'bool'>
浮点数。<class 'float'>
列表。<class 'list'>
元祖。<class 'tuple'>
字典。<class 'dict'>

字符串的方法：

  • find() 查找
str1="hello, welcome"
str2="hello"

print(str1.find(str2))

#输出
0
  • replace() 替换
str1="hello, welcome"
str2="hello"
print(str2.replace('hello','ddddd'))

#输出
ddddd
  • strip() 前后去空格
str3="  hello, welcome  "
print(str3)
print(str3.strip())

#输出
  hello, welcome  
hello, welcome
  • join(可迭代对象) 连接字符串
str="-"
str2=("a","b","c")
print(str.join(str2))

#输出
a-b-c
  • split() 分割
str="a1b1c1d1e1f"
print(str.split('1'))

#输出
['a', 'b', 'c', 'd', 'e', 'f']
  • format() 字符串格式化
print("{0} {1}".format("hello", "world"))

#输出
hello world

序列

是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

Python序列包含以下函数:

序号

函数

1

len(list) 列表元素个数

2

max(list) 返回列表元素最大值

3

min(list) 返回列表元素最小值

4

list(seq) 将元组转换为列表

str=["a","b","c","d","f","e"]
str2=["e","r","t","y","u","u","i"]
str3=(1,2,3)
print(len(str))
print(max(str))
print(min(str2))
print(list(str3))

#输出
6
f
e
[1, 2, 3]

Python序列包含以下方法:

序号

方法

1

list.append(obj) 在列表末尾添加新的对象

2

list.count(obj) 统计某个元素在列表中出现的次数

3

list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

4

list.index(obj) 从列表中找出某个值第一个匹配项的索引位置

5

list.insert(index, obj) 将对象插入列表

6

list.pop(obj=list[-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

7

list.remove(obj) 移除列表中某个值的第一个匹配项

8

list.reverse() 反向列表中元素

9

list.sort([func]) 对原列表进行排序

str=["a","b","c","d","f","e"]
str2=["e","r","t","y","u","u","i"]
str3=(1,2,3)
str.append("ffff")
print(str)
print(str2.count("u"))
str2.extend(str)
print(str2)
print(str.index("b"))
str.insert(2,"aaaa")
print(str)
print(str.pop(-2))
str.remove("a")
print(str)
str.reverse()
print(str)
str.sort()
print(str)

#输出
#插入元素
['a', 'b', 'c', 'd', 'f', 'e', 'ffff']
#打印字母u的数量
2
#str字符串接到str2的后面
['e', 'r', 't', 'y', 'u', 'u', 'i', 'a', 'b', 'c', 'd', 'f', 'e', 'ffff']
#字母b的下标
1
#在下标2的位置插入aaaa
['a', 'b', 'aaaa', 'c', 'd', 'f', 'e', 'ffff']
#pop出最后的值
e
#移除第一字母a
['b', 'aaaa', 'c', 'd', 'f', 'ffff']
#列表反转
['ffff', 'f', 'd', 'c', 'aaaa', 'b']
#列表排序
['aaaa', 'b', 'c', 'd', 'f', 'ffff']

元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

  • 例如
    tup2=(1,2,3,4,3,3)
  • 打印元素个数
tup2=(1,2,3,4,3,3)
print(tup2.count(3))

#输出
3
  • 例如打印下标
tup2=(1,2,3,4,3,3)
print(tup2.index(3))

#输出
2