Python常用数据结构和公共方法技巧总结

目录
  • 1. 列表
    • 1.1 列表的定义
    • 1.2 列表常用操作
    • 1.3 循环遍历
    • 1.4 应用场景
  • 2. 元组
    • 2.1 元组的定义
    • 2.2 元组常用操作
    • 2.3 循环遍历
    • 2.4 应用场景
  • 3. 字典
    • 3.1 字典的定义
    • 3.2 字典常用操作
    • 3.3 循环遍历
    • 3.4 应用场景
  • 4. 字符串
    • 4.1 字符串的定义
    • 4.2 字符串的常用操作
      • 1) 判断类型
      • 2) 查找和替换
      • 3) 大小写转换
      • 4) 文本对齐
      • 5) 去除空白字符
      • 6) 拆分和连接
    • 4.3 字符串的切片
    • 4.4 字符串的格式化输出
  • 5. 公共方法
    • 5.1 Python 内置函数
    • 5.2 切片
    • 5.3 运算符
    • 5.4 完整的 for 循环语法

1. 列表

1.1 列表的定义

  • List(列表) 是Python 中使用最频繁的数据类型,在其他语言中通常叫做数组
  • 专门用于存储一串 信息
  • 列表用[] 定义,数据之间使用, 分隔
  • 列表的索引0 开始
    • 索引就是数据在列表中的位置编号,索引又可以被称为下标

注意:从列表中取值时,如果 超出索引范围,程序会报错

name_list = ["zhangsan", "lisi", "wangwu"]

1.2 列表常用操作

  • ipython3 中定义一个列表,例如:name_list = []
  • 输入name_list. 按下TAB 键,ipython 会提示列表能够使用的方法如下:
In [1]: name_list.
name_list.append name_list.count name_list.insert name_list.reverse
name_list.clear name_list.extend name_list.pop name_list.sort
name_list.copy name_list.index name_list.remove

序号


分类


关键字 / 函数 / 方法


说明


1


增加


列表.insert(索引, 数据)


在指定位置插入数据

   
列表.append(数据)


在末尾追加数据

   
列表.extend(列表2)


将列表2 的数据追加到列表


2


修改


列表[索引] = 数据


修改指定索引的数据


3


删除


del 列表[索引]


删除指定索引的数据

   
列表.remove[数据]


删除第一个出现的指定数据

   
列表.pop


删除末尾数据

   
列表.pop(索引)


删除指定索引数据

   
列表.clear


清空列表


4


统计


len(列表)


列表长度

   
列表.count(数据)


数据在列表中出现的次数


5


排序


列表.sort()


升序排序

   
列表.sort(reverse=True)


降序排序

   
列表.reverse()


逆序、反转

del 关键字(科普):

  • 使用del 关键字(delete) 同样可以删除列表中元素
  • del 关键字本质上是用来将一个变量从内存中删除的
  • 如果使用del 关键字将变量从内存中删除,后续的代码就不能再使用这个变量了
del name_list[1]

在日常开发中,要从列表删除数据,建议 使用列表提供的方法

关键字、函数和方法(科普):

关键字是 Python 内置的、具有特殊意义的标识符

关键字后面不需要使用括号

函数封装了独立功能,可以直接调用

函数名(参数)

函数需要死记硬背

  • 方法和函数类似,同样是封装了独立的功能
  • 方法需要通过对象来调用,表示针对这个对象要做的操作

对象.方法名(参数)

在变量后面输入 .,然后选择针对这个变量要执行的操作,记忆起来比函数要简单很多

1.3 循环遍历

  • 遍历 就是 从头到尾依次 从 列表 中获取数据

    • 循环体内部针对每一个元素,执行相同的操作
  • Python 中为了提高列表的遍历效率,专门提供的 迭代 iteration 遍历
  • 使用for 就能够实现迭代遍历
# for 循环内部使用的变量 in 列表
for name in name_list:

循环内部针对列表元素进行操作
print(name)

1.4 应用场景

  • 尽管Python列表中可以存储不同类型的数据
  • 但是在开发中,更多的应用场景是
    • 列表存储相同类型的数据
    • 通过迭代遍历,在循环体内部,针对列表中的每一项元素,执行相同的操作

2. 元组

2.1 元组的定义

  • Tuple(元组)与列表类似,不同之处在于元组的元素不能修改

    • 元组表示多个元素组成的序列
    • 元组Python 开发中,有特定的应用场景
  • 用于存储一串 信息数据之间使用, 分隔
  • 元组用() 定义
  • 元组的索引0 开始
    • 索引就是数据在元组中的位置编号
info_tuple = ("zhangsan", 18, 1.75)

创建空元组:

info_tuple = ()

元组中只包含一个元素时,需要在元素后面添加逗号:

info_tuple = (50, )

2.2 元组常用操作

  • ipython3 中定义一个元组,例如:info = ()
  • 输入info. 按下TAB 键,ipython 会提示元组能够使用的函数如下:
info.count info.index

有关 元组 的 常用操作 可以参照上图练习

2.3 循环遍历

  • 取值就是从元组中获取存储在指定位置的数据
  • 遍历就是从头到尾依次元组中获取数据
# for 循环内部使用的变量 in 元组
for item in info:

循环内部针对元组元素进行操作
print(item)
  • Python 中,可以使用for 循环遍历所有非数字型类型的变量:列表元组字典以及字符串
  • 提示:在实际开发中,除非能够确认元组中的数据类型,否则针对元组的循环遍历需求并不是很多

2.4 应用场景

  • 尽管可以使用for in 遍历元组
  • 但是在开发中,更多的应用场景是:
    • 函数的 参数 和 返回值,一个函数可以接收任意多个参数,或者一次返回多个数据
  • 有关函数的参数 和 返回值,在后续函数高级给大家介绍
    • 格式字符串,格式化字符串后面的() 本质上就是一个元组
    • 让列表不可以被修改,以保护数据安全
info = ("zhangsan", 18)
print("%s 的年龄是 %d" % info)

元组和列表之间的转换:

  • 使用list 函数可以把元组转换成列表
list(元组)
  • 使用tuple 函数可以把列表转换成元组
tuple(列表)

3. 字典

3.1 字典的定义

  • dictionary(字典) 是除列表以外Python 之中最灵活的数据类型
  • 字典同样可以用来存储多个数据
    • 通常用于存储描述一个 物体 的相关信息
  • 和列表的区别
    • 列表有序的对象集合
    • 字典无序的对象集合
  • 字典用{} 定义
  • 字典使用键值对存储数据,键值对之间使用, 分隔
    • key 是索引
    • value 是数据
    • 之间使用: 分隔
    • 键必须是唯一的
    • 可以取任何数据类型,但只能使用字符串数字元组
xiaoming = {"name": "小明",
"age": 18,
"gender": True,
"height": 1.75}

3.2 字典常用操作

  • ipython3 中定义一个字典,例如:xiaoming = {}
  • 输入xiaoming. 按下TAB 键,ipython 会提示字典能够使用的函数如下:
In [1]: xiaoming.
xiaoming.clear xiaoming.items xiaoming.setdefault
xiaoming.copy xiaoming.keys xiaoming.update
xiaoming.fromkeys xiaoming.pop xiaoming.values
xiaoming.get xiaoming.popitem

有关 字典 的 常用操作 可以参照上图练习

3.3 循环遍历

  • 遍历就是依次字典中获取所有键值对
# for 循环内部使用的 `key 的变量` in 字典
for k in xiaoming:

print("%s: %s" % (k, xiaoming[k]))

提示:在实际开发中,由于字典中每一个键值对保存数据的类型是不同的,所以针对字典的循环遍历需求并不是很多

3.4 应用场景

  • 尽管可以使用for in 遍历字典
  • 但是在开发中,更多的应用场景是:
    • 使用多个键值对,存储描述一个 物体 的相关信息—— 描述更复杂的数据信息
    • 多个字典放在一个列表中,再进行遍历,在循环体内部针对每一个字典进行相同的处理
card_list = [{"name": "张三",
"qq": "12345",
"phone": "110"},
{"name": "李四",
"qq": "54321",
"phone": "10086"}
]

4. 字符串

4.1 字符串的定义

  • 字符串就是一串字符,是编程语言中表示文本的数据类型
  • 在 Python 中可以使用一对双引号" 或者一对单引号' 定义一个字符串
    • 虽然可以使用\" 或者\' 做字符串的转义,但是在实际开发中:
  • 如果字符串内部需要使用",可以使用' 定义字符串
  • 如果字符串内部需要使用',可以使用" 定义字符串
  • 可以使用索引获取一个字符串中指定位置的字符,索引计数从0开始
  • 也可以使用for循环遍历字符串中每一个字符

大多数编程语言都是用 " 来定义字符串

string = "Hello Python"

for c in string:
print(c)

4.2 字符串的常用操作

  • ipython3 中定义一个字符串,例如:hello_str = ""
  • 输入hello_str. 按下TAB 键,ipython 会提示字符串能够使用的方法如下:
In [1]: hello_str.
hello_str.capitalize hello_str.isidentifier hello_str.rindex
hello_str.casefold hello_str.islower hello_str.rjust
hello_str.center hello_str.isnumeric hello_str.rpartition
hello_str.count hello_str.isprintable hello_str.rsplit
hello_str.encode hello_str.isspace hello_str.rstrip
hello_str.endswith hello_str.istitle hello_str.split
hello_str.expandtabs hello_str.isupper hello_str.splitlines
hello_str.find hello_str.join hello_str.startswith
hello_str.format hello_str.ljust hello_str.strip
hello_str.format_map hello_str.lower hello_str.swapcase
hello_str.index hello_str.lstrip hello_str.title
hello_str.isalnum hello_str.maketrans hello_str.translate
hello_str.isalpha hello_str.partition hello_str.upper
hello_str.isdecimal hello_str.replace hello_str.zfill
hello_str.isdigit hello_str.rfind

提示:正是因为 python 内置提供的方法足够多,才使得在开发时,能够针对字符串进行更加灵活的操作!应对更多的开发需求!

1) 判断类型


方法


说明


string.isspace()


如果 string 中只包含空格,则返回 True


string.isalnum()


如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True


string.isalpha()


如果 string 至少有一个字符并且所有字符都是字母则返回 True


string.isdecimal()


如果 string 只包含数字则返回 True,全角数字


string.isdigit()


如果 string 只包含数字则返回 True,全角数字\u00b2


string.isnumeric()


如果 string 只包含数字则返回 True,全角数字汉字数字


string.istitle()


如果 string 是标题化的(每个单词的首字母大写)则返回 True


string.islower()


如果 string 中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True


string.isupper()


如果 string 中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True

2) 查找和替换


方法


说明


string.startswith(str)


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


string.endswith(str)


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


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


检测 str 是否包含在 string 中,如果 start 和 end 指定范围,则检查是否包含在指定范围内,如果是返回开始的索引值,否则返回 -1


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


类似于 find(),不过是从右边开始查找


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


跟 find() 方法类似,不过如果 str 不在 string 会报错


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


类似于 index(),不过是从右边开始


string.replace(old_str, new_str, num=string.count(old))


把 string 中的 old_str 替换成 new_str,如果 num 指定,则替换不超过 num 次

3) 大小写转换


方法


说明


string.capitalize()


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


string.title()


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


string.lower()


转换 string 中所有大写字符为小写


string.upper()


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


string.swapcase()


翻转 string 中的大小写

4) 文本对齐


方法


说明


string.ljust(width)


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


string.rjust(width)


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


string.center(width)


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

5) 去除空白字符


方法


说明


string.lstrip()


截掉 string 左边(开始)的空白字符


string.rstrip()


截掉 string 右边(末尾)的空白字符


string.strip()


截掉 string 左右两边的空白字符

6) 拆分和连接


方法


说明


string.partition(str)


把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面)


string.rpartition(str)


类似于 partition() 方法,不过是从右边开始查找


string.split(str=“”, num)


以 str 为分隔符拆分 string,如果 num 有指定值,则仅分隔 num + 1 个子字符串,str 默认包含 ‘\r’, ‘\t’, ‘\n’ 和空格


string.splitlines()


按照行(‘\r’, ‘\n’, ‘\r\n’)分隔,返回一个包含各行作为元素的列表


string.join(seq)


以 string 作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

4.3 字符串的切片

  • 切片方法适用于字符串列表元组

    • 切片使用索引值来限定范围,从一个大的字符串切出小的字符串
    • 列表元组都是有序的集合,都能够通过索引值获取到对应的数据
    • 字典是一个无序的集合,是使用键值对保存数据

字符串[开始索引:结束索引:步长]

注意

  • 指定的区间属于左闭右开[开始索引, 结束索引) =>开始索引 >= 范围 < 结束索引

    • 起始 位开始,到 结束位的前一位结束(不包含结束位本身)
  • 从头开始,开始索引数字可以省略,冒号不能省略
  • 到末尾结束,结束索引数字可以省略,冒号不能省略
  • 步长默认为1,如果连续切片,数字和冒号都可以省略

索引的顺序和倒序:

  • 在 Python 中不仅支持顺序索引,同时还支持倒序索引
  • 所谓倒序索引就是从右向左计算索引
    • 最右边的索引值是-1,依次递减

演练需求:

  • 截取从 2 ~ 5 位置 的字符串
  • 截取从 2 ~末尾 的字符串
  • 截取从开始 ~ 5 位置 的字符串
  • 截取完整的字符串
  • 从开始位置,每隔一个字符截取字符串
  • 从索引 1 开始,每隔一个取一个
  • 截取从 2 ~末尾 - 1 的字符串
  • 截取字符串末尾两个字符
  • 字符串的逆序(面试题)

答案

num_str = "0123456789"

# 1. 截取从 2 ~ 5 位置 的字符串
print(num_str[2:6])

# 2. 截取从 2 ~ `末尾` 的字符串
print(num_str[2:])

# 3. 截取从 `开始` ~ 5 位置 的字符串
print(num_str[:6])

# 4. 截取完整的字符串
print(num_str[:])

# 5. 从开始位置,每隔一个字符截取字符串
print(num_str[::2])

# 6. 从索引 1 开始,每隔一个取一个
print(num_str[1::2])

# 倒序切片
# -1 表示倒数第一个字符
print(num_str[-1])

# 7. 截取从 2 ~ `末尾 - 1` 的字符串
print(num_str[2:-1])

# 8. 截取字符串末尾两个字符
print(num_str[-2:])

# 9. 字符串的逆序(面试题)
print(num_str[::-1])

4.4 字符串的格式化输出

方法一:使用占位符

字符串格式化输出 是按照一种既定格式给字符串填空的方式,以便我们更加方便地写入字符串。

例如:

def print_intro(name, age, city):
intro = '我叫%s,今年 %d 岁,来自%s。' % (name, age, city)
print(intro)
print_intro('小贝', 18, '南京')
# 输出:我叫小贝,今年 18 岁,来自南京。

字符串格式化输出的语法规则:

% 运算符左边是要格式化的字符串,右边是一个元组。如果只有一个占位符,可以将元组里的元素拿出来,如:‘我叫%s’ % ‘小贝’。我们通过 %s、%d 这样的占位符在字符串中“占位”,Python 会将 % 右边的内容会按顺序替换掉对应的占位符,一一填空。每个占位符都有特定的含义,我们来看一下常见的占位符:

提示:如果你不太确定应该用什么占位符,%s 是万能的,它会把任何数据类型转换为字符串。

方法二:format()

例如:

'我叫{},今年 {} 岁,来自{}'.format('小贝', 18, '南京')
# 我叫小贝,今年 18 岁,来自南京

从上面的例子可以看到,format() 方法使用 {} 作为占位符,然后按照参数顺序替换对应的占位符。

我们还可以给占位符编号:

'我叫{0},今年 {1} 岁,来自{2}'.format('小贝', 18, '南京')
# 我叫小贝,今年 18 岁,来自南京

# 调整编号顺序
'我叫{2},今年 {1} 岁,来自{0}'.format('南京', 18, '小贝')
# 我叫小贝,今年 18 岁,来自南京

# 重复编号
'我叫{0},{0}今年 {1} 岁,来自{2}'.format('小贝', 18, '南京')
# 我叫小贝,小贝今年 18 岁,来自南京

我们还可以给占位符命名:

'我叫{name},今年 {age} 岁,来自{city}'.format(name = '小贝', age = 18, city = '南京')
# 我叫小贝,今年 18 岁,来自南京

# 命名后参数顺序不再重要
'我叫{name},今年 {age} 岁,来自{city}'.format(age = 18, city = '南京', name = '小贝')
# 我叫小贝,今年 18 岁,来自南京

5. 公共方法

5.1 Python 内置函数

Python 包含了以下内置函数:


函数


描述


备注


len(item)


计算容器中元素个数

 

del(item)


删除变量


del 有两种方式


max(item)


返回容器中元素最大值


如果是字典,只针对 key 比较


min(item)


返回容器中元素最小值


如果是字典,只针对 key 比较


cmp(item1, item2)


比较两个值,-1 小于/0 相等/1 大于


Python 3.x 取消了 cmp 函数

注意:字符串比较符合以下规则: “0” < “A” < “a”

5.2 切片

| 描述 | Python 表达式 | 结果 | 支持的数据类型 |
| :—: | — | — | — | — |
| 切片 | “0123456789”[::-2] | “97531” | 字符串、列表、元组 |

  • 切片使用索引值来限定范围,从一个大的字符串切出小的字符串
  • 列表元组都是有序的集合,都能够通过索引值获取到对应的数据
  • 字典是一个无序的集合,是使用键值对保存数据

5.3 运算符


运算符


Python 表达式


结果


描述


支持的数据类型


+


[1, 2] + [3, 4]


[1, 2, 3, 4]


合并


字符串、列表、元组


*


[“Hi!”] * 4


[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]


重复


字符串、列表、元组


in


3 in (1, 2, 3)


True


元素是否存在


字符串、列表、元组、字典


not in


4 not in (1, 2, 3)


True


元素是否不存在


字符串、列表、元组、字典


> >= == < <=


(1, 2, 3) < (2, 2, 3)


True


元素比较


字符串、列表、元组

注意:

  • in 在对字典操作时,判断的是字典的键
  • innot in 被称为成员运算符

成员运算符:

成员运算符用于 测试 序列中是否包含指定的 成员


运算符


描述


实例


in


如果在指定的序列中找到值返回 True,否则返回 False


3 in (1, 2, 3) 返回 True


not in


如果在指定的序列中没有找到值返回 True,否则返回 False


3 not in (1, 2, 3) 返回 False

注意:在对 字典 操作时,判断的是 字典的键

5.4 完整的 for 循环语法

Python 中完整的for 循环语法如下:

for 变量 in 集合:

循环体代码
else:
没有通过 break

应用场景:

  • 迭代遍历嵌套的数据类型时,例如一个列表包含了多个字典
  • 需求:要判断 某一个字典中 是否存在 指定的 值
    • 如果存在,提示并且退出循环
    • 如果不存在,在循环整体结束后,希望得到一个统一的提示
students = [
    {"name": "阿土",
     "age": 20,
     "gender": True,
     "height": 1.7,
     "weight": 75.0},
    {"name": "小美",
     "age": 19,
     "gender": False,
     "height": 1.6,
     "weight": 45.0},
]
find_name = "阿土"
for stu_dict in students:
    print(stu_dict)
    # 判断当前遍历的字典中姓名是否为find_name
    if stu_dict["name"] == find_name:
        print("找到了")
        # 如果已经找到,直接退出循环,就不需要再对后续的数据进行比较
        break
else:
    print("没有找到")
print("循环结束")

到此这篇关于Python常用数据结构和公共方法技巧总结的文章就介绍到这了,更多相关Python数据结构内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Python数据结构与算法中的队列详解(2)

    目录 传土豆 总结 传土豆 队列的一个典型方法是模拟需要以 FIFO 方式管理数据的真实场景.考虑这样一个游戏:传土豆.在这个游戏中,成员们围成一圈,并依次尽可能快地传递一个土豆.在某个时刻,大家停止传递,此时手里有土豆的成员就得退出游戏. 重复上述过程,直到只剩下一个成员. 我们将针对传土豆游戏实现通用的模拟程序.该程序接受一个名字列表和一个用于计数的常量 num ,并且返回最后剩下的那个人的名字. 我们使用队列来模拟一个环.即假设握着土豆的人位于队列的头部.在模拟传土豆的过程中,程序将这个人

  • Python数据结构与算法的双端队列详解

    目录 什么是双端队列​ ​用Python实现双端队列 运用双端队列构建回文检测器 总结 什么是双端队列​ 双端队列是与队列类似的有序集合.它有一前.一后两端,元素在其中保持自己的位置.与队列不同的是,双端队列对在哪一端添加和移除元素没有任何限制.新元素既可以被添加到前端,也可以被添加到后端.同理,已有的元素也能从任意一端移除.某种意义上,双端队列可以是栈和队列的结合. 值得注意的是,尽管双端队列有栈和队列的很多特性,但是它并不要求按照这两种数据结构分别规定的LIFO原则和FIFO原则操作元素.具

  • Python数据结构之队列详解

    目录 0. 学习目标 1. 队列的基本概念 1.1 队列的基本概念 1.2 队列抽象数据类型 1.3 队列的应用场景 2. 队列的实现 2.1 顺序队列的实现 2.2 链队列的实现 2.3 队列的不同实现对比 3. 队列应用 3.1 顺序队列的应用 3.2 链队列的应用 3.3 利用队列基本操作实现复杂算法 0. 学习目标 栈和队列是在程序设计中常见的数据类型,从数据结构的角度来讲,栈和队列也是线性表,是操作受限的线性表,它们的基本操作是线性表操作的子集,但从数据类型的角度来讲,它们与线性表又有

  • python库JsonSchema验证JSON数据结构使用详解

    目录 简单实例 type关键字 object关键字 属性 properties 必需属性 大小 数组属性 items List validation Tuple validation 长度 唯一性 通用关键字 元数据 枚举值 组合模式 anyOf oneOf allOf $schema关键字 正则表达式 构建复杂的模式 重用 JSON Schema是一个用于验证JSON数据结构的强大工具, 我查看并学习了JSON Schema的官方文档, 做了详细的记录, 分享一下. 我们可以使用JSON Sc

  • Python数据结构与算法中的队列详解(1)

    目录 什么是队列? 构建一个队列 总结 什么是队列? 队列,与栈类似,是有序集合.添加操作发生在 “尾部”,移除操作只发生在 “头部”.新元素只从尾部进入队列,然后一直向前移动到头部,直到成为下一个被移除的元素.​ 最新添加的元素必须在队列的尾部等待,在队列中时间最长的元素则排在最前面.这种排序原则被称作FIFO(first-in first-out),即先进先出,也称先到先得.在日常生活中,我们经常排队,这便是最简单的队列例子.进电影院要排队,在超市结账要排队,买咖啡也要排队.好的队列只允许一

  • Python数据结构之递归可视化详解

    目录 1.学习目标 2.递归的调用 3.递归可视化 3.1 turtle 库简介 3.1 递归绘图 1.学习目标 递归函数是直接调用自己或通过一系列语句间接调用自己的函数.递归在程序设计有着举足轻重的作用,在很多情况下,借助递归可以优雅的解决问题.虽然使用递归可以快速的解决一些难题,但由于递归的抽象性,使递归难以掌握.为了更好的理解递归函数背后的思想,本节主要通过可视化方式来了解递归函数的执行步骤. 通过本节学习,应掌握以下内容: 提高对递归的理解 利用可视化理解递归函数背后的思想 2.递归的调

  • Python基础知识+结构+数据类型

    目录 前言 一.编程基础 1.基本的输入输出 2.变量 3.基本运算符 二.控制流程 1.选择结构 2.循环结构 三.数据类型 1.字符串 前言 今天给大家分享一些Python的基础知识,想要盖好大房子,不把地基打扎实打牢怎么行呢?所以,今天咱们就来学习基础知识, 这样后期学习Python的时候才能更容易掌握,更轻松的学会Python的使用. 一.编程基础 1.基本的输入输出 print("Hello World"); Name = input('请输入您的姓名:'); print(N

  • Python数据结构之递归方法详解

    目录 1.学习目标 2.递归 2.1递归的基本概念 2.2递归的重要性 2.3递归三原则 2.4递归的应用 3.递归示例 3.1列表求和 3.2汉诺塔(Towers of Hanoi)问题 1.学习目标 递归函数是直接调用自己或通过一系列语句间接调用自己的函数.递归在程序设计有着举足轻重的作用,在很多情况下,借助递归可以优雅的解决问题.本节主要介绍递归的基本概念以及如何构建递归程序. 通过本节学习,应掌握以下内容: 理解递归的基本概念,了解递归背后蕴含的编程思想 掌握构建递归程序的方法 2.递归

  • Python常用数据结构和公共方法技巧总结

    目录 1. 列表 1.1 列表的定义 1.2 列表常用操作 1.3 循环遍历 1.4 应用场景 2. 元组 2.1 元组的定义 2.2 元组常用操作 2.3 循环遍历 2.4 应用场景 3. 字典 3.1 字典的定义 3.2 字典常用操作 3.3 循环遍历 3.4 应用场景 4. 字符串 4.1 字符串的定义 4.2 字符串的常用操作 1) 判断类型 2) 查找和替换 3) 大小写转换 4) 文本对齐 5) 去除空白字符 6) 拆分和连接 4.3 字符串的切片 4.4 字符串的格式化输出 5.

  • python使用数字与字符串方法技巧

    目录 1. 少使用数字字面量 2. 裸字符串处理的问题 3. 展开复杂的计算字面量表达式 4.实用技巧 4.1布尔值也是数字 4.2改善字符串的可读性. 4.3以 r 开头的内建字符串函数. 4.4 float (" inf ") 5.常见误区 5.1“value += 1” 并非线程安全 5.2字符串拼接并不慢 1. 少使用数字字面量 下面的代码使用数字来作为判断条件的语句,如果你从别人手里接手过这部分代码,很难第一时间理解它的意义. def mark_trip_as_feature

  • python常用数据结构字典梳理

    目录 dict字典 字典定义与使用 字典使用:创建 字典使用:访问元素 字典使用:操作元素 字典使用:嵌套字典 字典常用方法 values() items() values() get() update() pop() 字典推导式 dict字典 字典定义与使用 字典的定义: 字典是无序的键值对集合 字典用大括号{}包围 每个键/值对之间用一个逗号分隔 各个键与值之间用一个冒号分隔 字典是动态的 字典使用:创建 创建字典: --使用大括号填充键值对 --通过构造方法dict() --使用字典推导式

  • Python 常用模块 re 使用方法详解

    一.re模块的查找方法: 1.findall   匹配所有每一项都是列表中的一个元素 import re ret = re.findall('\d+','asd鲁班七号21313') # 正则表达式,待匹配的字符串,flag # ret = re.findall('\d','asd鲁班七号21313') # 正则表达式,待匹配的字符串,flag # print(ret) 2.search 只匹配从左到右的第一个,等到的不是直接的结果,而是一个变量,通过这个变量的group方法来获取结果 impo

  • 浅析python常用数据文件处理方法

    0.前言 虽说python运行速度慢,但其编程速度,第三方包的丰富度是真的高. 涉及到文件批处理还是会选择python. 1. 动态文件名 在文件批处理中,文件名经常只有编号是不同的,可以通过给字符串传递不同的编号来获取动态文件名. file_num = 324 # file_num = 1 for i in range(file_num): file_name = "正常数据\\{}.正常.txt".format(i + 1) ... 2. 将文件转换为csv格式 一般数据提供者为了

  • python常用数据结构元组详解

    目录 Tuple 元组 元组的定义和使用 元组常用方法 index(item) count(item):返回某个元素出现的次数 元组解包 元组与列表 Tuple 元组 元组的定义和使用 元组的定义: 元组是有序的不可变对象集合 元组使用小括号包围,各个对象之间使用逗号分隔 元组是异构的,可以包含多种数据类型 元组使用:创建 创建: --使用逗号分隔 --通过小括号填充元素 --通过构造方法tuple(iterable)-----iterable:可迭代对象 --注意:单元素元组,逗号不可或缺 #

  • python常用数据结构集合详解

    目录 set集合 集合定义与使用 集合常用方法 add() update() remove() discard() pop() clear() 集合运算 交集运算 并集运算 差集运算 集合推导式 set集合 集合定义与使用 集合定义: --无序的唯一对象集合 --用大括号{}包围,对象相互之间使用逗号分隔 --集合是动态的,可以随时添加或删除元素 --集合是异构的,可以包含不同类型的数据 集合使用:创建 创建: --通过使用{}填充元素 --通过构造方法set() --通过集合推导式 # 集合使

  • Python cookbook(数据结构与算法)通过公共键对字典列表排序算法示例

    本文实例讲述了Python通过公共键对字典列表排序算法.分享给大家供大家参考,具体如下: 问题:想根据一个或多个字典中的值来对列表排序 解决方案:利用operator模块中的itemgetter()函数对这类结构进行排序是非常简单的. # Sort a list of a dicts on a common key rows = [ {'fname': 'Brian', 'lname': 'Jones', 'uid': 1003}, {'fname': 'David', 'lname': 'Be

  • Python cookbook(数据结构与算法)从字典中提取子集的方法示例

    本文实例讲述了Python从字典中提取子集的方法.分享给大家供大家参考,具体如下: 问题:想创建一个字典,其本身是另一个字典的子集 解决方案:利用字典推导式(dictionary comprehension)可轻松解决 # example of extracting a subset from a dictionary from pprint import pprint prices = { 'ACME': 45.23, 'AAPL': 612.78, 'IBM': 205.55, 'HPQ':

  • Python cookbook(数据结构与算法)将多个映射合并为单个映射的方法

    本文实例讲述了Python将多个映射合并为单个映射的方法.分享给大家供大家参考,具体如下: 问题:在逻辑上将多个字典或映射合并为一个单独的映射结构,以此执行某些特定的操作,比如查找值或者检查键是否存在 解决方案:利用collections模块中的ChainMap类 ChainMap可接受多个映射然后在逻辑上使它们表现为一个单独的映射结构.这些映射在字面上并不会合并在一起.相反,ChainMap只是简单地维护一个记录底层映射关系的列表,然后重定义常见的字典操作来扫描这个列表. # example.

随机推荐