数据分析师入门python必会知识

Python基础必会知识点

1. 简述 Python 中的几种数据类型

• 整数(int)
• 浮点数(float)
• 复数(complex)
• 字符串(str)
• 布尔值(bool)
• 空值(None)

容器：

• 列表list
• 元组tuple
• 字典dict
• 集合set

2. 数据类型的可变与不可变分别有哪些？

可变数据类型

        列表（List），

# 创建一个列表
my_list = [1, 2, 3, 4, 5]

# 修改列表中的元素
my_list[0] = 10

# 在列表末尾插入一个元素
my_list.append(6)

# 删除列表中的元素
my_list.remove(3)

print(my_list)  # 输出：[10, 2, 4, 5, 6]

        字典（Dictionary）

# 创建一个字典
my_dict = {"name": "Alice", "age": 20, "city": "Beijing"}

# 修改字典中的值
my_dict["age"] = 25

# 插入新的键值对
my_dict["gender"] = "female"

# 删除字典中的键值对
del my_dict["city"]

print(my_dict)  # 输出：{"name": "Alice", "age": 25, "gender": "female"}

        集合（Set）

# 创建一个集合
my_set = {1, 2, 3, 4, 5}

# 添加元素
my_set.add(6)

# 删除元素
my_set.remove(3)

print(my_set)  # 输出：{1, 2, 4, 5, 6}

        字节数组（Bytearray）：字节数组是一个可变的字节序列，可以进行修改、插入和删除操作。

# 创建一个字节数组
my_bytearray = bytearray(b"hello")

# 修改字节数组中的值
my_bytearray[0] = ord("H")

# 在字节数组中插入一个字节
my_bytearray.insert(5, ord("!"))

# 删除字节数组中的一个字节
my_bytearray.remove(ord("o"))

print(my_bytearray)  # 输出：bytearray(b'Hello!')

        队列（queue）

import queue  
  
q = queue.Queue()

q.put(1)    # 插入元素1，队列变为[1]  
q.put(2, 1) # 插入元素2，优先级为1，队列变为[1, 2]  
q.put(3)    # 插入元素3，队列变为[1, 2, 3]

x = q.get()   # 删除队头元素1，x的值为1，队列变为[2, 3]  
y = q.get()   # 删除队头元素2，y的值为2，队列变为[3]  
z = q.get()   # 删除队头元素3，z的值为3，队列变为空[]

q.empty()   # 返回True，因为队列为空

q.qsize()   # 返回0，因为队列为空

不可变的数据类型

        

1. 数字（Numbers）：Python中的整数int、浮点数float和复数complex都是不可变的。一旦创建了数字对象，就无法更改其值。
2. 字符串（Strings）：字符串也是不可变的。这意味着您无法更改字符串中的字符或将其拆分为多个字符串。
3. 元组（Tuples）：元组是不可变的序列，类似于字符串，您无法更改元组中的元素。
4. 布尔值（Booleans）：布尔值具有两个可能的值：True和False，并且无法更改。
5. 冻结集合（Frozensets）：冻结集合是元组的不可变版本，它允许您使用集合操作，但不能更改其中的元素。
6. 类型本身（Types）：除了上述提到的具体数据类型之外，Python还有一些内置的类型，如int、float、complex、str、tuple和bool，它们都是不可变的。

        

3. 元组，列表，字典有没有长度的限制?

        python这些列表,字典和元组，理论上是没有长度限制的。

        但是，实际上，Python中的元组、列表和字典都有长度限制，具体取决于Python解释器的可用内存的大小。

对于元组和列表，它们的长度限制通常是可用内存的大小。如果尝试创建超出可用内存大小的对象，Python解释器将引发MemoryError异常。

对于字典，虽然它们可以容纳任意数量的键值对，但是它们的长度（即键值对的数量）也是有限制的。在Python 3中，字典的最大长度取决于可用内存的大小和系统架构。同样，如果尝试创建超出可用内存大小的字典对象，Python解释器将引发MemoryError异常。

需要注意的是，具体的长度限制可能会因Python解释器的实现而有所不同。因此，建议在编写代码时合理地管理数据结构的大小，以确保程序的效率和稳定性。

4. 集合有那些特性

无序性：不能知道某一个元素具体在集合中的哪一个位置，所以不能对集合进行切片的操作。

元素的不可重复性：元素是不重复的，即集合中的每个元素只出现一次。可以用于去重.

可以进行数学集合操作，如并集、交集、差集、对称差集和对称交集

5. 分别解释"=","==","+="的含义

“=”是赋值

“==”是判断二者是否相等，相等为True，不相等为False

“+=”

        a+=2   等价于  a=a+2

6. 解释'and','or','not'

逻辑运算符

“and”  要求严格，只有二者同时为True 才判定为True, 二者有一个False  就是False

“or”  要求松，二者有一个True 就是True, 二者都为False才是False.

"not", not True就是False, not False 就是True

7. 深浅 copy-引用和 copy(),deepcopy()的区别

引用：

• 在Python中，变量实际上是对象的引用。当你创建一个对象并将其赋值给一个变量时，这个变量就成为了一个指向该对象的引用。
• 如果两个变量引用同一个对象，那么当修改其中一个变量时，另一个变量也会受到影响。这是因为它们都引用同一个对象。
• 这种情况通常被称为“引用传递”。在Python中，大多数对象（如列表、字典等）都是通过引用传递的。但是，一些内建类型（如数字、字符串和元组）是按值传递的。

import copy
c = [1, 2, [3, 4]]
d = c

a = [1, 2, [3, 4]]
b = copy.deepcopy(a)

浅拷贝

• 当我们创建一个新的对象并将其赋值给另一个变量时，Python会创建一个新的引用指向原始对象，这就是所谓的浅拷贝。
• 换句话说，浅拷贝创建了一个新的引用，但并没有创建新的对象。因此，如果我们对新对象进行修改，原始对象也会受到影响。
• 在Python中，你可以使用copy模块的copy()函数来实现浅拷贝。

# 创建一个列表  
original_list = [1, 2, [3, 4]]  
  
# 浅拷贝  
shallow_copy = copy.copy(original_list)  
shallow_copy[2][0] = 'a'  # 修改浅拷贝的子对象，原始列表也会被修改  
print(original_list)  # 输出：[1, 2, ['a', 4]]  

深拷贝：

• 深拷贝与浅拷贝不同，它创建了一个新的对象，并且复制了原始对象的所有子对象。这意味着，当你对新的复制对象进行修改时，原始对象不会受到影响。
• 在Python中，你可以使用copy模块的deepcopy()函数来实现深拷贝。

# 创建一个列表  
original_list = [1, 2, [3, 4]]  

# 深拷贝  
deep_copy = copy.deepcopy(original_list)  
deep_copy[2][0] = 'a'  # 修改深拷贝的子对象，原始列表不会受影响  
print(original_list)  # 输出：[1, 2, [3, 4]]

Python基础必会练手题

1. 求 1-100 之间能被 7 整除，但不能同时被 5 整除的所有整数

for i in range(1,101,1):
    if i%7==0 and i%5==0:
        print(i)

# 35
# 70

2. 输出 1000 以内所有的"⽔仙花数"，所谓"⽔仙花数"是指⼀个三位数，其各 位数字⽴⽅和等于该数本身。例如：153 是⼀个"⽔仙花数"，因为 153=1 的三次 ⽅＋5 的三次⽅＋3 的三次⽅

for i in range(100,1000,1):
    if i == int(str(i)[0])**3+int(str(i)[1])**3+int(str(i)[2])**3:
        print(i)

153
370
371
407

3. 判断 101-200 之间有多少个素数，并输出所有素数一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数

for i in range(101,200):
    is_prime = True
    for j in range(2,i,1):
        if i % j == 0:
            is_prime = False
            break
    if is_prime == True:
        print(i)

101
103
107
109
113
127
131
137
139
149
151
157
163
167
173
179
181
191
193
197
199

4. 设 m=1×2···×n,求 m 为不⼤于 20000 时最⼤的 n

n=1
p=1
while True:

    p = p*(n)
    print("print(n)", end="\t");print(n, end="\t")
    print("print(p)", end="\t");print(p)
    
    if p > 20000:
        print(n)
        break
    n+=1

print(n)	1	print(p)	1
print(n)	2	print(p)	2
print(n)	3	print(p)	6
print(n)	4	print(p)	24
print(n)	5	print(p)	120
print(n)	6	print(p)	720
print(n)	7	print(p)	5040
print(n)	8	print(p)	40320
8

5. 利用 if 语句写出猜大小的游戏。预设⼀个 0-9 的随机整数，让⽤户输⼊所猜的数。如果⼤于预设的数，提示“bigger”；如果⼩于预设的数，显示“smaller”。如此循环，直⾄猜中该数，显示
“right！”，并统计第几次猜中。

import random
ans = random.randint(0,9)
print(ans)
while True:
    guess = int(input("请输入你猜的数"))
    if guess > ans:
        print("bigger")
    elif guess < ans:
        print("smaller")
    else:
        print("猜中了，是",ans)
        break

6. 读⼊⼀串字符，判断是否是回⽂串。“回⽂串”是⼀个正读和反读都⼀样的 字符串，⽐如“level”或者“noon”等等就是回⽂串。 输⼊ ⼀⾏字符串，⻓度不超过 255。 输出如果是回⽂串，输出“YES”，否则输出“NO”。

def is_palin(i_str):
    if i_str==i_str[::-1]:
        print("YES")
    else:
        print("NO")
is_palin("level")
is_palin("noon")
is_palin("right")

YES
YES
NO

7. 一球从 100 米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10 次落地时，共经过多少米？第 10 次反弹多高？

def fall_resil(start=100):
    h = start
    resil = 1
    mile = start
    
    for i in range(1,11,1):
        h = h/2
        mile += h*2
    print("在第10 次落地时， 共经过多少米?\t", mile)
    print("第 10 次反弹多高？\t", h)
        
fall_resil()    

在第10 次落地时， 共经过多少米?	 299.8046875
第 10 次反弹多高？	 0.09765625

8. 使用 while,完成以下图形的输出

# *
# * *
# * * *
# * * * *
# * * * * *
# * * * *
# * * *
# * *
# *

i = 1
while True:
    if i < 6:
        print("* "*i)
    else:
        break
    i+=1
    
i = 4
while True:
    if i >= 1:
        print("* "*i)
    else:
        break
    i-=1

9. 输⼊某年某⽉某⽇，判断这⼀天是这⼀年的第⼏天？

year = int(input("year: "))
month = int(input("month:"))
day = int(input("day:"))

m_dict = {1:31,3:31,4:30, 5:31, 6:30, 7:31, 8:31, 9:30, 10:31, 11:30, 12:31}

# （1）能被4整除且不能被100整除（如2004年是闰年，而1900年不是）
# （2）能被400整除（如2000年是闰年）
if (year%4==0 and year%100!=0) or (year % 400 == 0):
    m_dict[2] = 29
else:
    m_dict[2] = 28

total_day = 0
for m in range(1,month,1):
    total_day += m_dict[m]
    
total_day += day
    
print("这⼀天是这⼀年的第%s天"%(total_day))

year: 2023
month:10
day:7
这⼀天是这⼀年的第280天

10. 定义一个列表名为 nameList，里面包含 6 个元素；

（1）.查看一下列表的长度

（2）.实现列表的增（增加一个元素）、删（删除第二个元素）、改（修改第一个
元素）、查（查询第一个元素）

nameList = [1,2,3,4,5,6]
nameList.append(7); print(nameList)
nameList.extend([11,22]);print(nameList)

nameList.remove(1);print(nameList)

nameList[2]=99999;print(nameList)

nameList.index(5)

[1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7, 11, 22]
[2, 3, 4, 5, 6, 7, 11, 22]
[2, 3, 99999, 5, 6, 7, 11, 22]
3

11. 使用计数器方式（统计一下’飘飘乎如遗世独立，羽化而登仙乎’这一句话中的每个字符出现的个数），以及出现最多的 2 个数。

s1 = "飘飘乎如遗世独立，羽化而登仙乎"
s_dict = {}
for i in s1:
    if i not in s_dict.keys():
        s_dict[i] = 1
    else:
        s_dict[i] += 1
print(s_dict);print("\n\n")


import operator; 
# s_dict.items() 是把字典中的键值对取出，
    # dict_items([('飘', 2), ('乎', 2), ('如', 1), ('遗', 1), ('世', 1), ('独', 1), ('立', 1), ('，', 1), ('羽', 1), ('化', 1), ('而', 1), ('登', 1), ('仙', 1)])
print(sorted(s_dict.items(),key=operator.itemgetter(1),reverse=True))
# sorted函数第一个元素表示被排序的数据
# operator.itemgetter(1)表示获取每个元组的第二个元素作为排序依据。
# 具体来说，operator.itemgetter(1)是一个函数，它接受一个可迭代对象作为输入，并返回一个新的迭代器。这个迭代器产生原始可迭代对象的第二个元素。
print(dict(sorted(s_dict.items(),key=operator.itemgetter(1),reverse=True)));print("\n\n")

print(sorted(s_dict.items(),key=operator.itemgetter(1),reverse=True)[0:2])

{'飘': 2, '乎': 2, '如': 1, '遗': 1, '世': 1, '独': 1, '立': 1, '，': 1, '羽': 1, '化': 1, '而': 1, '登': 1, '仙': 1}



[('飘', 2), ('乎', 2), ('如', 1), ('遗', 1), ('世', 1), ('独', 1), ('立', 1), ('，', 1), ('羽', 1), ('化', 1), ('而', 1), ('登', 1), ('仙', 1)]
{'飘': 2, '乎': 2, '如': 1, '遗': 1, '世': 1, '独': 1, '立': 1, '，': 1, '羽': 1, '化': 1, '而': 1, '登': 1, '仙': 1}



[('飘', 2), ('乎', 2)]