Python基础（一）

变量的类型及应用方法

变量的类型：
  • Numbers（数字）：
    * int（有符号整型）
    * float（浮点型）
    * long（长整型）
    * complex（复数）
  • Bool类型：
    * True（真）
    * False （假）
  • String（字符串）
  • List（列表）
  • Tuple（元组）
  • Dictionary（字典）
  • Set（集合）
查看变量的类型：

type(变量名)

常用的数据类型转换 :

函数

说明

int(x)

将x转换为一个整数

float(x)

将x转换为一个浮点数

str(x)

将对象 x 转换为字符串

tuple(s)

将序列 s 转换为一个元组

list(s)

将序列 s 转换为一个列表

eval（str)

用来计算在字符串中的有效Python表达式,并返回一个对象

运算符

算术运算符

运算符

描述

实例

+

加

两个对象相加 a + b 输出结果 30

-

减

得到负数或是一个数减去另一个数 a - b 输出结果 -10

*

乘

两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200

/

除

b / a 输出结果 2

//

取整除

返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

%

取余

返回除法的余数 b % a 输出结果 0

**

指数

a**b 为10的20次方， 输出结果 100000000000000000000

注意：混合运算时，优先级顺序为： ** 高于 * / % // 高于 + - ，为了避免歧义，建议使用 () 来处理运算符优先级。
并且，不同类型的数字在进行混合运算时，整数将会转换成浮点数进行运算。

赋值运算符

运算符

描述

实例

=

赋值运算符

把 = 号右边的结果 赋给 左边的变量，如 num = 1 + 2 * 3，结果num的值为7

+=

加法赋值运算符

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

比较运算符

运算符

描述

实例

==

检查两个操作数的值是否相等，如果是则条件变为真

如a=3,b=3，则（a == b) 为 True

!=

检查两个操作数的值是否相等，如果值不相等，则条件变为真

如a=1,b=3，则(a != b) 为 True

>

检查左操作数的值是否大于右操作数的值，如果是，则条件成立

如a=7,b=3，则(a > b) 为 True

<

检查左操作数的值是否小于右操作数的值，如果是，则条件成立

如a=7,b=3，则(a < b) 为 False

>=

检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立

如a=3,b=3，则(a >= b) 为 True

<=

检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立

如a=3,b=3，则(a <= b) 为 True

逻辑运算符

运算符

描述

实例

and

布尔"与"：如果 x 为 False，x and y 返回 False，否则它返回 y 的值

True and False， 返回 False

or

布尔"或"：如果 x 是 True，它返回 True，否则它返回 y 的值

False or True， 返回 True

not

布尔"非"：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True

not True 返回 False, not False 返回 True

容器类型的常见操作

通用的操作

方法

描述

序列[位置下标]

通过下标快速找到对应的数据（字符串、列表、元组）

序列[start: end: 步长]

用于获取操作对象的局部数据（字符串、列表、元组）

+

连接、拼接数据（字符串、列表、元组）

*

重复（字符串、列表、元组）

in

判断元素是否在 序列 中，如果存在那么结果为true，否则为false（字符串、列表、元组、字典、集合）

not in

判断元素是否不在在 序列 中，如果不存在那么结果为true，否则false（字符串、列表、元组、字典、集合）

.len()

求容器中数据的数量

.max()

求容器中数据的最大值

.min()

求容器中数据的最小值

.enumerate()

枚举出容器中的数据

下标：又叫“索引”，默认从0开始
下标和切片需依赖下标，所有操作的数据必须是有序的，如：字符串、列表、元组等

推导式

类型

用法

列表推导式

new_list = [表达式 for i in … if 条件]

字典推导式

new_dict = {key: value for … in …if 条件}

集合推导式

new_set = {表达式 for i in …if 条件}

类型转化

用法

描述

list(序列)

转列表，有序可改变可重复

tuple(序列)

转元组, 有序不可变可重复

set(序列)

转集合，无序可改变不重复

循环遍历

类型

用法

描述

除字典外

for data in dict: print(data)

遍历数据

字典

for data in dict: print(data)

遍历key

字典

for key in dict.keys(): print(key)

遍历key

字典

for value in dict.values(): print(value)

遍历value

字典

for item in dict.items(): print(item)

遍历item，以(key,value)形式出现（元组）

字典

for key,value in dict.items(): print(key,value)

遍历item，以key,value形式出现

字符串的常用操作

描述：字符串是最常用的数据类型，也称字符序列
字符串定义：‘xxx’ ， “xxx” ， “”“xxx”""， ‘’‘xxx’’’， ‘x"x’ ， “x’x”， “x’x”

查找

方法

用法

描述

.find()

mystr.find(str, start=0, end=len(mystr))

查找 str 是否在start和end之间，如果是返回开始的索引值，否则返回-1

.rfind()

mystr.rfind(str, start=0, end=len(mystr))

(从右往左)查找 str 是否在start和end之间，如果是返回开始的索引值，否则返回-1

.index()

mystr.index(str, start=0, end=len(mystr))

查找 str 是否在start和end之间，如果是返回开始的索引值，否则会报一个异常

.rindex()

mystr.rindex(str, start=0, end=len(mystr))

(从右往左) 查找 str 是否在start和end之间，如果是返回开始的索引值，否则会报一个异常

.count()

mystr.count(str, start=0, end=len(mystr))

计数：str 在start和end之间在 mystr 里面出现的次数

修改

方法

用法

描述

.replace(old,new)

mystr.replace(str1, str2, mystr.count(str1))

把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次

.split(分隔符)

mystr.split(str, maxsplit)

分割字符串：返回一个列表，丢失分隔符如果 maxsplit有指定值，则仅用 maxsplit 个分隔符分割

分隔符.join(list)

mystr.join(str)

mystr 列表中每个元素后面插入str,构造出一个新的字符串

.partition()

mystr.partition(str)

把mystr以str分割成三部分,str前，str和str后，返回一个元组

.rpartition()

mystr.rpartition(str)

从右边开始，把mystr以str分割成三部分,str前，str和str后，返回一个元组

.splitlines()

mystr.splitlines()

按照行分隔，返回一个包含各行作为元素的列表

判断

方法

用法

描述

.startswith()

mystr.startswith(str)

检查字符串是否是以 str 开头, 是则返回 True，否则返回 False

.endswith()

mystr.endswith(str)

检查字符串是否以 str 结束，是返回True,否则返回 False

.isdigit()

mystr.isdigit()

如果 mystr 只包含数字则返回 True 否则返回 False

.isalpha()

mystr.isalpha()

如果 mystr 所有字符都是字母 则返回 True,否则返回 False

.isalnum()

mystr.isalnum()

如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False

.isspace()

mystr.isspace()

如果 mystr 中只包含空格，则返回 True，否则返回 False

大小写转换

方法

用法

描述

.upper()

mystr.upper()

转换 mystr 中的小写字母为大写

.lower()

mystr.lower()

转换 mystr 中的小写字母为小写

.capitalize()

mystr.capitalize()

把字符串的第一个字符大写

.title()

mystr.title()

把字符串的每个单词首字母大写

去空白

方法

用法

描述

.strip()

mystr.strip()

删除mystr字符串两端的空白字符

.lstrip()

mystr.lstrip()

删除 mystr 左边的空白字符

.rstrip()

mystr.rstrip()

删除 mystr 字符串末尾的空白字符

对齐

方法

用法

描述

.ljust()

mystr.ljust(width)

返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

.rjust()

mystr.rjust(width)

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

.center()

mystr.center(width)

返回一个原字符串居中,并使用空格填充至长度 width 的新字符串

列表的常用操作

描述：用于存储批量且可变的有序数据
空列表：[]、list()
列表：list1=[‘A’,‘B’,‘C’]

增加

方法

用法

描述

.append()

mylist.append(元素)

列表尾部增加元素

.insert()

mylist.insert(index, object)

在指定位置index前插入元素object

.extend()

mylist.extend(系列)

将另一个集合中的元素逐一添加到列表中

删除

方法

用法

描述

.remove()

mylist.remove(数据)

删除该数据，不返回该值

.pop()

mylist.pop(index)

index不指定，默认删除最后一位，并返回该值

.clear()

mylist.clear()

清空列表里的元素

del

del mylist[index]/del list

删除指定位置数据/删除整个列表变量

修改和排序

方法

用法

描述

list[index]

mylist[index] = 值

修改指定下标的值

.reverse()

mylist.reverse()

将mylist的元素逆置

.sort()

mylist.sort()

将mylist的元素顺序排序

.sort(reverse=True)

mylist.sort(reverse=True)

将mylist的元素逆序排序

查询

方法

用法

描述

.index()

mylist.index(元素, start=0, end=len(mylist))

查找：元素 是否在start和end之间，如果是返回开始的索引值，否则会报一个异常

.count()

mylist.count(元素, start=0, end=len(mylist))

计数：元素 在start和end之间在 mylist 里面出现的次数

元组的常用操作

描述：一种存储批量的不可变的有序数据
单个数据：tuple1=(数据1,)
多个数据：tuple1=(数据1，数据2， 数据3…)

查询

方法

用法

描述

.index()

mytuple.index(元素, start=0, end=len(mytuple))

查找：元素 是否在start和end之间，如果是返回开始的索引值，否则会报一个异常

.count()

mytuple.count(元素, start=0, end=len(mytuple))

计数：元素 在start和end之间在 mytuple 里面出现的次数

字典的常用操作

描述：字典就是以键值对方式存储多个数据，键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。
空字典：{}、dict()
字典：dict1 = {key1:value1,key2:value2,key3:value3…}

增加/修改

方法

用法

描述

dict1[key]

dict1[key] = 值

如果这个 key 在字典中，就直接修改 key 对应的值，如果不存在，那么就会新增这个元素

.update()

dict1.update(dict2)

把字典dict2的键/值对更新到dict1里

删除

方法

用法

描述

.pop(key)

dict1.pop(key)

删除指定 key 的键值对，如果不指定key，默认随机删除一位 ，如果key不存在，会报异常

.popitem()

dict1.popitem()

返回并删除字典中的最后一对键和值

.clear()

dict1.clear()

清空字典中的元素

del

del dict1[key]/del dict1

删除指定位置数据/删除整个字典变量

查询

方法

用法

描述

dict1[key]

dict1[key]

查询指定key，若key不存在，会报错

.get(key)

dict1.get(key)

查询指定key，若key不存在，不会报错，返回None

.keys()

dict1.keys()

查询所有的key，并且输出一个可迭代(遍历)的格式

.values()

dict1.values()

查询所有的value，并且输出一个可迭代(遍历)的格式

.items()

dict1.items()

查询所有的item，并且输出一个可迭代(遍历)的格式

集合的常用操作

描述:集合是一种存储批量无序的不重复数据，集合是可变类型，但里面的元素是不可变类型（可以自动去重复）
空集合：set()
集合：set1 = {数据1， 数据2， 数据3…}

增加

方法

用法

描述

.add()

set1.add(数据)

增加不可改变类型的数据,如字符串、元组等

.update()

set1.update(系列)

增加可拆分的系列数据,如字符串、列表等

删除

方法

用法

描述

.remove()

set1.remove(数据)

删除指定数据，若数据不存在，会报错

.discard()

set1.discard(数据)

删除指定数据，若数据不存在，不会报错

.pop()

set1.pop(数据)

不指定数据，默认随机删除一位，若数据不存在，会报错

.clear()

set1.clear()

清空集合数据

筛选

方法

用法

描述

.union()

set1.union(set2)

返回包含一个包含set1和set2所有元素的集

.intersection()

set1.intersection(set2)

返回一个包含两个集共有元素的集

.difference()

set1.difference(set2)

返回一个集，其中仅包含只出现在set1中的元素，去除共有的元素

.intersection()

set1.intersection(set2)

返回一个包含两个集共有元素的集