100天的第2天数据科学训练营从NOOB到专家。

github链接：Complete-Data-Science-Bootcamp

主要帖子：Complete-Data-Science-Bootcamp

回顾第1天

昨天我们研究了有关Python基础知识的INM。

我们将在这方面研究什么...

在本课程中，我们将深入研究Python中的各种内置数据结构，并探索如何通过详细的示例和练习在程序中使用它们。我们将介绍列表，元组，集合和词典等数据结构，并讨论其独特的特征和用途。在本课程结束时，您将对这些数据结构有牢固的了解，并能够在Python程序中自信地利用它们。

Python具有几个内置数据结构或数据类型，包括：

整数（int） - 用于表示整数
float-用于表示浮点值
复杂 - 用来表示复数
boolean（bool） - 用于表示布尔值（true或false）
字符串（str） - 用于表示字符序列
列表 - 用于表示元素的有序序列
元组 - 用于表示无法修改的元素的有序序列
集 - 用于表示独特元素的无序集
冷冻集 - 用于表示无法修改的独特元素的无序集
字典 - 用于表示键值对
无 - 用来表示没有值。

在第1天，我们简要讨论了这些主题的基础知识，但是现在我们将在List，Tuple，Set和Dictionary上更详细地深入研究它们。

列表

基本：

列表是订购和可变的项目的集合。列表用方括号编写，这些物品通过逗号分隔。

my_list1 = [1, 2, 3, 4] # this is a list with four integers my_list2 = ['apple', 'banana', 'cherry'] # this is a list with three strings my_list3 = [1, 'apple', 3.14, True] # this is a list with four items of different data types print(my_list1) print(my_list2) print(my_list3)

[1, 2, 3, 4] ['apple', 'banana', 'cherry'] [1, 'apple', 3.14, True]

有几种方法可以在Python中创建或声明列表：

使用方括号：您可以通过封装逗号分隔的项目中的项目中的列表来创建列表。

my_list1 = [1, 2, 3, 4, 5] # this is a list of integers my_list2 = ['apple', 'banana', 'cherry'] # this is a list of strings my_list3 = [1, 'apple', 3.14, True] # this is a list of items with different data types print(my_list1) print(my_list2) print(my_list3)

[1, 2, 3, 4, 5] ['apple', 'banana', 'cherry'] [1, 'apple', 3.14, True]

使用list（）函数：您可以通过将序列传递到list（）函数来创建列表。

my_list1 = list(range(10)) # creates a list of integers from 0 to 9 my_list2 = list('abcdefg') # creates a list of characters from the string print(my_list1) print(my_list1)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

使用列表理解：您可以使用带有列表理解的一行创建列表。

my_list1 = [x for x in range(10)] # creates a list of integers from 0 to 9 my_list2 = [x for x in 'abcdefg'] # creates a list of characters from the string print(my_list1) print(my_list1)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

使用 *操作员：您可以通过使用 *操作员复制现有列表来创建列表。

my_list1 = [1, 2, 3] * 3 # creates a list with three copies of [1, 2, 3] my_list2 = [1] * 10 # creates a list with ten copies of the integer 1 my_list3 = ['hello'] * 5 # creates a list with five copies of the string 'hello' print(my_list1) print(my_list2) print(my_list3)

[1, 2, 3, 1, 2, 3, 1, 2, 3] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ['hello', 'hello', 'hello', 'hello', 'hello']

访问项目：

您可以使用其索引访问列表中的项目。第一个项目的索引从0开始，每个后续项目都上升1。

my_list = [1, 2, 3, 4] print(my_list[0]) # prints 1 (the first item in the list) print(my_list[2]) # prints 3 (the third item in the list)

1 3

更改项目：

您可以通过为其索引分配新值来更改列表中项目的值。

my_list = [1, 2, 3, 4] my_list[0] = 5 # changes the value of the first item in the list to 5 print(my_list) # prints [5, 2, 3, 4]

[5, 2, 3, 4]

添加项目：

您可以使用append()方法或insert()方法将项目添加到列表中。

append()方法将项目添加到列表的末尾。

my_list = [1, 2, 3, 4] my_list.append(5) # adds 5 to the end of the list print(my_list) # prints [1, 2, 3, 4, 5]

[1, 2, 3, 4, 5]

insert()方法在指定的索引中添加项目。

my_list = [1, 2, 3, 4] my_list.insert(1, 5) # adds 5 at index 1 (between 1 and 2) print(my_list) # prints [1, 5, 2, 3, 4]

[1, 5, 2, 3, 4]

删除项目：

您可以使用remove()方法或pop()方法从列表中删除项目。

remove()方法删除了该项目的第一次出现。

my_list = [1, 2, 3, 4, 5, 5] my_list.remove(5) # removes the first occurrence of 5 print(my_list) # prints [1, 2, 3, 4, 5]

[1, 2, 3, 4, 5]

pop()方法删除了指定索引处的项目并返回项目。

my_list = [1, 2, 3, 4] item = my_list.pop(1) # removes the item at index 1 (2) and assigns it to the variable "item" print(my_list) # prints [1, 3, 4] print(item) # prints 2

[1, 3, 4] 2

查找列表的长度：

您可以使用Len（）函数找到列表的长度。

my_list = [1, 2, 3, 4] print(len(my_list)) # prints 4

4

先进的：

这是python中列表的一些更高级的功能：

切片：

您可以通过指定一系列索引来切片列表以访问其中的一部分。

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # access the first three items in the list print(my_list[0:3]) # prints [1, 2, 3] # access the middle four items in the list print(my_list[3:7]) # prints [4, 5, 6, 7] # access the last three items in the list print(my_list[-3:]) # prints [8, 9, 10] # access all items in the list print(my_list[:]) # prints [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

[1, 2, 3] [4, 5, 6, 7] [8, 9, 10] [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

排序：

您可以使用sorted（）函数或sort（）方法对列表进行排序。

sorted（）函数返回一个新的排序列表，而sort（）

my_list = [3, 5, 1, 4, 2] #sort the list using the sorted() function sorted_list = sorted(my_list) print(sorted_list) # prints [1, 2, 3, 4, 5] print(my_list) # prints [3, 5, 1, 4, 2] #sort the list using the sort() method my_list.sort() print(my_list) # prints [1, 2, 3, 4, 5]

[1, 2, 3, 4, 5] [3, 5, 1, 4, 2] [1, 2, 3, 4, 5]

撤销：

您可以使用reververs（）方法来反向列表。

my_list = [1, 2, 3, 4, 5] # reverse the list using the reverse() method my_list.reverse() print(my_list) # prints [5, 4, 3, 2, 1]

[5, 4, 3, 2, 1]

使用切片反向

my_list = [1, 2, 3, 4, 5] # reverse using slicing print(my_list[::-1])

[5, 4, 3, 2, 1]

列表理解：

列表理解是使用一行代码创建列表的简洁方法。

# create a list of squares of the numbers 0 to 9 squares = [x**2 for x in range(10)] print(squares) # prints [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] # create a list of even numbers between 10 and 20 even_numbers = [x for x in range(10, 21) if x % 2 == 0] print(even_numbers) # prints [10, 12, 14, 16, 18, 20]

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] [10, 12, 14, 16, 18, 20]

循环：

您可以使用for Loop循环浏览列表中的项目。

# loop through the items in a list and print each one my_list = [1, 2, 3, 4, 5] for item in my_list: print(item) # loop through the items in a list and print their index and value my_list = ['apple', 'banana', 'cherry'] for i, item in enumerate(my_list): print(i, item) # output: # 0 apple # 1 banana # 2 cherry

1 2 3 4 5 0 apple 1 banana 2 cherry

枚举：

枚举（）函数返回带有列表中每个项目的索引和值的元组。

my_list = ['apple', 'banana', 'cherry'] for i, item in enumerate(my_list): print(i, item)

0 apple 1 banana 2 cherry

过滤：

您可以过滤列表以仅包含使用条件的列表理解符合某些条件的项目。

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # filter the list to only include even numbers even_numbers = [x for x in my_list if x % 2 == 0] print(even_numbers) # prints [2, 4, 6, 8, 10] # filter the list to only include numbers greater than 5 greater_than_five = [x for x in my_list if x > 5] print(greater_than_five) # prints [6, 7, 8, 9, 10]

[2, 4, 6, 8, 10] [6, 7, 8, 9, 10]

映射：

您可以使用列表理解。

my_list = [1, 2, 3, 4, 5] # multiply each item in the list by 2 doubled_list = [x * 2 for x in my_list] print(doubled_list) # prints [2, 4, 6, 8, 10] # convert each item in the list to a string string_list = [str(x) for x in my_list] print(string_list) # prints ['1', '2', '3', '4', '5']

[2, 4, 6, 8, 10] ['1', '2', '3', '4', '5']

最大和最低：

您可以使用max（）和min（）函数在列表中找到最大值和最小值。

my_list = [1, 2, 3, 4, 5] # find the maximum value in the list max_value = max(my_list) print(max_value) # prints 5 # find the minimum value in the list min_value = min(my_list) print(min_value) # prints 1

5 1

和：

您可以使用sum（）函数在列表中找到所有值的总和。

my_list = [1, 2, 3, 4, 5] # find the sum of all the values in the list total = sum(my_list) print(total) # prints 15

15

多维列表：

列表还可以包含其他列表，创建一个多维列表。

# create a 2D list with 3 rows and 4 columns my_list = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]] # access the first item in the first row print(my_list[0][0]) # prints 1 # access the second item in the second row print(my_list[1][1]) # prints 6 # access the fourth item in the third row print(my_list[2][3]) # prints 12

1 6 12

结论：

列表是Python中功能强大且通用的数据结构。它们允许您以有序的方式存储和操纵物品集合。您可以使用各种方法和功能在列表中访问，更改，添加，删除和操纵项目。您还可以使用列表理解，循环和其他高级技术来更有效地使用列表。

元组

元组是Python中不变的序列类型。它类似于列表，因为它可以包含多个值，但是与列表不同，元组中的值一旦创建就无法修改。这使得元组更有效地存储和操纵不需要修改的数据。

这是如何创建元组的示例

my_tuple = (1, 2, 3) print(my_tuple)

(1, 2, 3)

您还可以通过在元素之后加入逗号来创建带有单个元素的元组：

my_tuple = (1,) print(my_tuple)

(1,)

没有逗号，python将把括号视为括号，而不是元组的语法：

my_tuple = (1) print(my_tuple)

1

您可以使用索引访问元组的元素，就像您在列表中一样。

例如：

my_tuple = (1, 2, 3) print(my_tuple[0]) print(my_tuple[1]) print(my_tuple[2])

1 2 3

您也可以使用切片来访问元组中的一系列元素：

my_tuple = (1, 2, 3, 4, 5) print(my_tuple[1:3])

(2, 3)

元组还支持所有常见的序列操作，例如串联，重复和成员资格测试：

my_tuple = (1, 2, 3) print(my_tuple * 3) #Output: (1, 2, 3, 1, 2, 3, 1, 2, 3) print(my_tuple + (4, 5, 6)) #Output: (1, 2, 3, 4, 5, 6) print(3 in my_tuple) #Output: True print(4 in my_tuple) #Output: False

(1, 2, 3, 1, 2, 3, 1, 2, 3) (1, 2, 3, 4, 5, 6) True False

元组通常用于存储相关数据，例如一个人的名称和年龄：

person = ("John", 30) name, age = person print(name) #Output: "John" print(age) # Output: 30

John 30

套

一组是Python中独特元素的集合。它类似于列表或元组，但是无序的，不允许重复的值。

这是如何在Python中创建集合的示例：

# create an empty set my_set = set() print(my_set) # create a set with values my_set = {1, 2, 3, 4} print(my_set) # create a set from a list my_list = [1, 2, 3, 4, 2] my_set = set(my_list) # {1, 2, 3, 4} print(my_set)

set() {1, 2, 3, 4} {1, 2, 3, 4}

可以使用各种方法来修改集合，例如add（），update（），remove（）和distard（）。

# create a set with values my_set = {1, 2, 3, 4} print(my_set) # add an element to the set my_set.add(5) print(my_set) # add multiple elements to the set my_set.update([6, 7, 8]) print(my_set) # remove an element from the set my_set.remove(5) print(my_set) # remove an element from the set if it exists, otherwise do nothing my_set.discard(5) print(my_set) # clear all elements from the set my_set.clear() print(my_set)

{1, 2, 3, 4} {1, 2, 3, 4, 5} {1, 2, 3, 4, 5, 6, 7, 8} {1, 2, 3, 4, 6, 7, 8} {1, 2, 3, 4, 6, 7, 8} set()

集合也可以用于执行集合操作，例如联合，交叉和差异。

set1 = {1, 2, 3} set2 = {2, 3, 4} # find the union of two sets union = set1.union(set2) # {1, 2, 3, 4} print(union) # find the intersection of two sets intersection = set1.intersection(set2) # {2, 3} print(intersection) # find the difference between two sets difference = set1.difference(set2) # {1} print(difference)

{1, 2, 3, 4} {2, 3} {1}

总体而言，集合对于在Python中存储和操纵唯一值很有用。

它们对于执行集合操作特别有用，例如查找两组之间的交点或差异。

这是如何使用集合在两个列表之间找到共同元素的示例：

list1 = [1, 2, 3, 4, 5] list2 = [4, 5, 6, 7, 8] # convert the lists to sets set1 = set(list1) set2 = set(list2) # find the intersection of the sets common = set1.intersection(set2) # {4, 5} # convert the intersection back to a list common_list = list(common) print(common_list) # [4, 5]

[4, 5]

集合对于从列表中删除重复项也很有用。这是如何做到这一点的示例：

my_list = [1, 2, 3, 4, 4, 5, 5, 6, 6] # convert the list to a set to remove duplicates my_set = set(my_list) # convert the set back to a list unique_list = list(my_set) print(unique_list) # [1, 2, 3, 4, 5, 6]

[1, 2, 3, 4, 5, 6]

结论

集合是Python中强大的数据结构，并且有许多用途。关于集的一些其他知识还包括：

集合是无序的，这意味着这些元素不是以特定顺序存储的。这意味着您无法像列表或元组一样访问索引集中的元素。

集合是可变的，这意味着您可以在创建之后从集合中添加或删除元素。

集合未索引，这意味着您不能使用索引中的索引中的索引或元组来引用集合中的元素。

集合不可切片，这意味着您不能使用slice operator（[：]）来提取像您可以使用列表或元组一样的集合的一部分。

集合不可订阅，这意味着您不能使用下标运算符（[]）访问集合中的元素，就像您可以使用列表或元组一样。

集合不支持串联，这意味着您不能使用 +运算符将两个集合与列表或元组相结合。

集合不支持重复，这意味着您不能使用 *操作员像使用列表或元组一样重复集合。

您可以看到，与Python中的其他数据结构相比，集合有一些局限性。但是，它们仍然是您工具包中拥有的有用工具，尤其是在使用唯一值或执行设置操作时。

字典

词典是Python中的钥匙值对的集合。它类似于列表或元组，但是您不使用索引访问元素，而是使用键。

这是如何在python中创建字典的示例：

# create an empty dictionary my_dict = {} # create a dictionary with values my_dict = {'key1': 'value1', 'key2': 'value2'} print(my_dict) # create a dictionary from a list of tuples my_list = [('key1', 'value1'), ('key2', 'value2')] my_dict = dict(my_list) print(my_dict)

{'key1': 'value1', 'key2': 'value2'} {'key1': 'value1', 'key2': 'value2'}

词典可以使用各种方法进行修改，例如update（），setDefault（）和pop（）。

# create a dictionary with values my_dict = {'key1': 'value1', 'key2': 'value2'} print(my_dict) # add a key-value pair to the dictionary my_dict['key3'] = 'value3' print(my_dict) # update multiple key-value pairs in the dictionary my_dict.update({'key4': 'value4', 'key5': 'value5'}) print(my_dict) # set a default value for a key if it does not exist my_dict.setdefault('key6', 'default value') print(my_dict) # remove a key-value pair from the dictionary my_dict.pop('key3') print(my_dict)

{'key1': 'value1', 'key2': 'value2'} {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'} {'key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4', 'key5': 'value5'} {'key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4', 'key5': 'value5', 'key6': 'default value'} {'key1': 'value1', 'key2': 'value2', 'key4': 'value4', 'key5': 'value5', 'key6': 'default value'}

字典也可以用于执行字典操作，例如合并和过滤。

dict1 = {'key1': 'value1', 'key2': 'value2'} dict2 = {'key3': 'value3', 'key4': 'value4'} # merge two dictionaries merged_dict = {**dict1, **dict2} # {'key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4'} print(merged_dict) # filter a dictionary based on a condition filtered_dict = {k: v for k, v in merged_dict.items() if v == 'value2'} # {'key2': 'value2'} print(filtered_dict)

{'key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4'} {'key2': 'value2'}

这是如何使用词典存储和检索学生成绩的示例：

student_grades = { 'John': {'math': 85, 'english': 90}, 'Mary': {'math': 95, 'english': 80}, 'Bob': {'math': 75, 'english': 70} } print(student_grades) # retrieve John's math grade john_math_grade = student_grades['John']['math'] # 85 print(john_math_grade) # update Mary's english grade student_grades['Mary']['english'] = 95 print(student_grades)

{'John': {'math': 85, 'english': 90}, 'Mary': {'math': 95, 'english': 80}, 'Bob': {'math': 75, 'english': 70}} 85 {'John': {'math': 85, 'english': 90}, 'Mary': {'math': 95, 'english': 95}, 'Bob': {'math': 75, 'english': 70}}

结论

字典是Python中有力的数据结构，并且有许多用途。关于词典还有一些其他知识包括：

词典是可变的，这意味着您可以在创建字典中添加或删除键值对。

词典是无序的，这意味着键值对不以特定顺序存储。

词典不支持切片，这意味着您不能使用slice operator（[：]）像用列表或元组一样提取字典的一部分。

字典不支持串联，这意味着您不能使用 +运算符将两个字典（如列表或元组）结合在一起。

字典不支持重复，这意味着您不能使用 *操作员像用列表或元组一样重复字典。

Python的功能

在Python中，一个函数是执行特定任务的代码块，可以通过其他代码调用。函数可以采用参数（也称为参数）并返回结果。

这是Python中简单功能的示例：

def greet(name): print("Hello, " + name) greet("John") # prints "Hello, John"

Hello, John

在此示例中，函数问候以一个参数，名称并打印出来。该函数与参数“约翰”一起调用，因此它打印为“你好，约翰”。

功能还可以返回值而不是打印值。例如：

def add(x, y): return x + y result = add(3, 4) # stores 7 in result print(result) # prints 7

7

在此示例中，函数添加需要两个参数x和y，并返回其总和。当函数与参数3和4调用时，它返回7，然后将其存储在变量结果中并打印。

函数可以具有其参数的默认值。例如：

def greet(name, greeting="Hello"): print(greeting + ", " + name) greet("John") # prints "Hello, John" greet("John", "Hi") # prints "Hi, John"

Hello, John Hi, John

在此示例中，函数问候为问候参数的默认值“ hello”，因此，如果在调用该函数时没有提供问候的值，它将使用“ Hello”作为默认值。

函数可以使用 *args语法进行任意数量的参数。例如：

def sum_all(*args): result = 0 for num in args: result += num return result print(sum_all(1, 2, 3)) # prints 6 print(sum_all(1, 2, 3, 4, 5)) # prints 15

6 15

在此示例中，函数sum_all获取任意数量的参数并返回其总和。这些论点被视为元组，因此您可以像其他元组一样访问它们。

函数还可以使用** kwargs语法进行任意数量的关键字参数。例如：

def print_keyword_args(**kwargs): for key, value in kwargs.items(): print(key + ": " + value) print_keyword_args(name="John", age='30', city="New York")

name: John age: 30 city: New York

在此示例中，函数print_keyword_args进行任意数量的关键字参数并打印它们。关键字参数被视为字典，因此您可以像其他任何字典一样访问它们。

函数可以使用元组返回多个值。例如：

def min_max(numbers): return (min(numbers), max(numbers)) (min_val, max_val) = min_max([1, 2, 3, 4, 5]) print(min_val) # prints 1 print(max_val) # prints 5

1 5

在此示例中，函数min_max返回包含输入列表中最小值和最大值的元组。然后将元组拆开到变量min_val和max_val中。

您将在Github的第2天的练习笔记本中找到练习问题。

如果您喜欢它，然后...