21天打卡进阶Python基础操作

python21天打卡day3-python数据类型

在这里插入图片描述

#int
a=2
print(a)
print(type(a))
#float
a=2.2
print(a)
print(type(a))
#string
a='nihao'
print(a)
print(type(a))
#list
a=[1,2,3,4]
print(a)
print(a[0])
print(type(a))
#元组
a=(1,2)
print(a)
print(type(a))
#字典dict
a={'name':'yangyal','age':'13'}
print(a)
print(a['name'])
print(type(a))

输出：

D:\学习\Python工程\venv\Scripts\python.exe D:/学习/Python工程/practice/test_demo.py
2
<class 'int'>
2.2
<class 'float'>
nihao
<class 'str'>
[1, 2, 3, 4]
1
<class 'list'>
(1, 2)
<class 'tuple'>
{'name': 'yangyal', 'age': '13'}
yangyal
<class 'dict'>

Process finished with exit code 0

python21天打卡day4-字符串操作

在这里插入图片描述

data_string='21 day python'
print("截取")
print(data_string[:])#输出原字符串
print(data_string[1:9])
print(data_string[:-1])#倒着输出一位
print(data_string[0:])#输出原字符串
print(data_string[::-1])#翻转
print("字符串的连接")
print(data_string + 'hello world')

print(('复制当前的字符串'))
data_string2=data_string*2
print(data_string2)

print(("占位符"))
print("%s"%data_string)

D:\学习\Python工程\venv\Scripts\python.exe D:/学习/Python工程/practice/test_demo.py
截取
21 day python
1 day py
21 day pytho
21 day python
nohtyp yad 12
字符串的连接
21 day pythonhello world
复制当前的字符串
21 day python21 day python21 day python
占位符
21 day python

Process finished with exit code 0

python21天打卡Day5–list操作

在这里插入图片描述

#列表
data_list=[21,'day','python']
#索引
print(data_list[0])#输出第一位
print(data_list[-1])#输出最后一位

#切片
print(data_list[:-1])
print(data_list[::-1])#倒序输出

#列表的连接
data_list.append('hello world')

#对列表的赋值
print(data_list*2)
data_list[1:2]='may'
print(data_list)

D:\学习\Python工程\venv\Scripts\python.exe D:/学习/Python工程/practice/test_demo.py
21
python
[21, 'day']
['python', 'day', 21]
[21, 'day', 'python', 'hello world', 21, 'day', 'python', 'hello world']
[21, 'm', 'a', 'y', 'python', 'hello world']

Process finished with exit code 0

python21天打卡Day6-元组

在这里插入图片描述

data_tuple=(21,'day','python')
#索引
print(data_tuple[0])
print(data_tuple[-1])
#切片
print(data_tuple[:-1])#0到-1 不包括-1？
print(data_tuple[::-1])

#写出包含一个元素的元组
a=(1,)
print(type(a))
print(a)
#如果元组只有一个元素，需要加逗号，否则输出是int

#拆包
data_1,data_2,data_3=data_tuple
print(data_1)
print(data_2)
print(data_3)
#元组和列表的区别

D:\学习\Python工程\venv\Scripts\python.exe D:/学习/Python工程/practice/test_demo.py
21
python
(21, 'day')
('python', 'day', 21)
<class 'tuple'>
(1,)
21
day
python

Process finished with exit code 0

python21天打卡day7-字典

在这里插入图片描述

data_dict={'location':'shenzhen','province':'guangzhou','age':25}
#访问字典内的值
print(data_dict['age'])

#修改字典
data_dict['sex']=1 #给字典加值
print(data_dict)

#删除字典
del data_dict['sex']
print(data_dict)

D:\学习\Python工程\venv\Scripts\python.exe D:/学习/Python工程/practice/test_demo.py
25
{'location': 'shenzhen', 'province': 'guangzhou', 'age': 25, 'sex': 1}
{'location': 'shenzhen', 'province': 'guangzhou', 'age': 25}

Process finished with exit code 0

python21天打卡Day8-string，int互转

在这里插入图片描述

a='21'
int(a)#默认是十进制
print("{},{}".format(a,type(a)))
b='21'
int(b,16)
print("{},{}".format(b,type(b)))
c=21
str(c)
print("{},{}".format(c,type(c)))

d=21
hex(d)
print("{},{}".format(d,type(d)))

D:\学习\Python工程\venv\Scripts\python.exe D:/学习/Python工程/practice/test_demo.py
21,<class ‘str’>
21,<class ‘str’>
21,<class ‘int’>
21,<class ‘int’>

Process finished with exit code 0

字符串的10进制和16进制有什么区别？

python21天打卡Day9-string和dict类型互转

在这里插入图片描述

a="{'name':'idoxu','sex':'male','age':30}"
b=eval(a) #eval函数能把字符串转为字典？
print(b)
print(type(b))

c="{'name':'idoxu','sex':'male','age':30}"
exec(c)#exec函数能把字符串转为字典 但是为什么转弯后还是str?
print(c)
print(type(c))


d={'name':'idoxu','sex':'male','age':30}
for key,value in d.items():
    print("\"%s\":\"%s\"" % (key, value))

D:\学习\Python工程\venv\Scripts\python.exe D:/学习/Python工程/practice/test_demo.py
{'name': 'idoxu', 'sex': 'male', 'age': 30}
<class 'dict'>
{'name':'idoxu','sex':'male','age':30}
<class 'str'>
"name":"idoxu"
"sex":"male"
"age":"30"

Process finished with exit code 0

python21天打卡Day10-string和bytes互转

在这里插入图片描述

a=‘21 python’
b=a.encode(‘utf-8’)#string转为bytes
print(‘{},{}’.format(b,type(b)))

c=b’21 python’
d=c.decode(‘utf-8’)
print(‘{},{}’.format(d,type(d)))

D:\学习\Python工程\venv\Scripts\python.exe D:/学习/Python工程/practice/test_demo.py
b’21 python’,<class ‘bytes’>
21 python,<class ‘str’>

Process finished with exit code 0

Python21天打卡Day11-dict和json格式互转

在这里插入图片描述

import json
a={'name':'idoxu','sex':'male','age':30}
b=json.dumps(a)#把字典转为json
print('{},{}'.format(b,type(b)))
#json的格式是字符串

c='{"name":"idoxu","sex":"male","age":30}'
d=json.loads(c)#json转为dict
#the JSON object must be str, bytes or bytearray, not dict
print('{},{}'.format(d,type(d)))

e={"name":"idoxu","sex":"male","age":30}
print('{},{}'.format(e,type(e)))

{“name”: “idoxu”, “sex”: “male”, “age”: 30},<class ‘str’>
{‘name’: ‘idoxu’, ‘sex’: ‘male’, ‘age’: 30},<class ‘dict’>
{‘name’: ‘idoxu’, ‘sex’: ‘male’, ‘age’: 30},<class ‘dict’>

python21天打卡Day12–for循环，列表推导式-构建列表

在这里插入图片描述

#for循环
a=[]
#range从左开始，不包括右 如下输出1-100
for i in range(1,101):
    a.append(i)
print(a)
#列表推导式
b=[i for i in range(1,101)]
print(b)

D:\学习\Python工程\venv\Scripts\python.exe D:/学习/Python工程/practice/test_demo.py
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]

Process finished with exit code 0

Python21天打卡Day13-生成器表达式

写一个生成器表达式，检查所写类型是否为生成器？

Python 的生成器（Generator）是一种特殊的迭代器，它是一种函数或方法，可以在执行过程中多次产生值而不是一次性返回所有值。

生成器的定义方式和普通函数一样，但是它使用 yield 语句来产生一个值。当生成器的代码执行到 yield 语句时，会暂停执行，并将产生的值返回给调用者。之后，每次调用生成器的 __next__() 方法或使用 for 循环迭代时，生成器都会继续执行并在下一个 yield 语句处暂停，再次返回一个值。

下面是一个简单的生成器示例：

def my_generator():
    yield 1
    yield 2
    yield 3

# 使用生成器
gen = my_generator()
print(next(gen))  # 输出：1
print(next(gen))  # 输出：2
print(next(gen))  # 输出：3

在上面的例子中，my_generator() 是一个生成器函数，它通过使用 yield 语句，分别生成值 1、2 和 3。每次调用 next() 方法时，生成器都会从上次 yield 语句停止的地方继续执行，并返回下一个产生的值。

生成器的主要优势是不会一次性生成并保存所有值，而是按需一次产生一个值，这在处理大量数据或需要逐步产生结果时非常有用。此外，生成器还可以有效地节省内存和提高性能。

您还可以使用生成器表达式来创建简洁的生成器，类似于列表推导式。例如：

gen = (x for x in range(1, 4))
for num in gen:
    print(num)

这将产生与前面示例相同的输出。生成器表达式在圆括号中定义，并使用类似于列表推导式的语法。它可以用于在更简洁的方式下生成值序列。
在这里插入图片描述

N=(i**2 for i in range(1,11))
print(next(N))
print(next(N))
print(next(N))

在这里插入图片描述
每次输出一个N。

Python21天打卡Day14-随机字符串

在这里插入图片描述
import random
import string
a=“”.join(random.sample(string.ascii_letters,6))
b=“”.join(random.sample(string.digits,8))
print(a)
print(b)

D:\学习\Python工程\venv\Scripts\python.exe D:/学习/Python工程/practice/test_demo.py
LklhFG
23968471

Process finished with exit code 0

Python21天打卡Day16-内置方法map()

在 Python 中，map() 方法是一个内置的函数，用于将函数应用于可迭代对象（如列表、元组等）中的每个元素，返回一个包含结果的迭代器。

map() 方法的语法如下：

map(function, iterable)

function：表示要应用于可迭代对象中每个元素的函数。
iterable：表示要进行映射操作的可迭代对象，例如列表、元组等。

map() 方法会将 iterable 中的每个元素依次传入 function 中，并将返回的结果收集到一个迭代器中，最后返回该迭代器。如果 iterable 中的长度不同，map() 方法会以最短的长度为准，忽略多余的元素。

下面是使用 map() 方法的一个简单示例：

def square(x):
    return x ** 2

numbers = [1, 2, 3, 4, 5]
squared_numbers = map(square, numbers)

print(list(squared_numbers))  # 输出：[1, 4, 9, 16, 25]

在上面的例子中，square() 函数定义了一个平方操作，numbers 是一个列表，包含了要进行平方操作的整数。通过 map(square, numbers)，将 square() 函数应用于 numbers 列表中的每个元素，并返回一个迭代器。使用 list() 函数将迭代器转换为列表，得到最终的结果 [1, 4, 9, 16, 25]。

使用 lambda 表达式可以更简洁地定义映射函数，例如：

numbers = [1, 2, 3, 4, 5]
squared_numbers = map(lambda x: x ** 2, numbers)

print(list(squared_numbers))  # 输出：[1, 4, 9, 16, 25]

这将产生与前面示例相同的结果，但使用了匿名函数 lambda 来定义平方操作。map() 方法在很多情况下都可以用于简化对可迭代对象的操作，例如数值转换、字符串处理等。

Python21天打卡Day17-内置方法filter()

在 Python 中，filter() 方法是一个内置的函数，用于筛选出满足指定条件的元素，并返回一个包含这些元素的迭代器。

filter() 方法的语法如下：

filter(function, iterable)

function：表示用于筛选元素的函数，返回值为布尔类型（True 或 False）。
iterable：表示要进行筛选操作的可迭代对象，如列表、元组等。

filter() 方法会遍历 iterable 中的每个元素，并将每个元素传入 function 中进行判断。如果 function 返回 True，则保留该元素；如果返回 False，则排除该元素。最终，将筛选出的元素收集到一个迭代器中返回。

下面是使用 filter() 方法的一个简单示例：

def is_even(x):
    return x % 2 == 0

numbers = [1, 2, 3, 4, 5]
even_numbers = filter(is_even, numbers)

print(list(even_numbers))  # 输出：[2, 4]

在上面的例子中，is_even() 函数用于判断一个数是否为偶数。通过 filter(is_even, numbers)，将 is_even() 函数应用于 numbers 列表中的每个元素，并返回一个迭代器。使用 list() 函数将迭代器转换为列表，得到最终的结果 [2, 4]，即筛选出的偶数。

与 map() 方法类似，使用 lambda 表达式可以更简洁地定义筛选条件，例如：

numbers = [1, 2, 3, 4, 5]
even_numbers = filter(lambda x: x % 2 == 0, numbers)

print(list(even_numbers))  # 输出：[2, 4]

这将产生与前面示例相同的结果，但使用了匿名函数 lambda 来定义判断偶数的条件。filter() 方法在很多情况下都可以用于筛选出满足特定条件的元素，并且可以与 lambda 表达式一起使用来进行简单而灵活的筛选操作。

Python21天打卡Day18 lambda函数

在 Python 中，lambda 是一个用于创建匿名函数的关键字。它可以被用来在一行内定义简单的函数，通常用于需要传递函数作为参数的地方或在需要一个临时函数的场景中使用。

lambda 函数的语法如下：

lambda arguments: expression

arguments 是参数列表，可以包含零个或多个参数，参数之间用逗号分隔。
expression 是一个表达式，用于定义函数的计算逻辑，并返回计算结果。

下面是使用 lambda 的示例：

# 定义一个简单的 lambda 函数，计算两个数的和
add = lambda x, y: x + y

result = add(3, 4)
print(result)  # 输出：7

在上面的例子中，使用 lambda 定义了一个匿名函数 add，它接受两个参数 x 和 y，并返回它们的和。然后，通过调用 add(3, 4)，将参数值传递给这个匿名函数，并得到了计算结果 7。

lambda 函数可以在需要一个函数对象的地方使用，比如作为参数传递给高阶函数（如 map()、filter()）或用于简化函数的定义。然而，要注意的是，由于 lambda 函数只能包含一个表达式，所以不能包含复杂的逻辑或多个语句。

使用 lambda 函数可以使代码更简洁，但也要注意保持代码的可读性和易于维护。根据具体的需求和使用场景，选择使用 lambda 函数或者命名的函数来实现代码逻辑。

Python21天打卡Day19-位置参数、默认参数

在 Python 中，位置参数是一种常见的函数参数类型。当定义函数时，我们可以为函数指定位置参数，以便在调用函数时按照指定的顺序传递相应的参数值。

位置参数的特点如下：

在函数定义的过程中，我们需要为函数指定参数的名称，这些参数就是位置参数。
在函数调用时，需要按照参数列表中位置的顺序，逐个传递参数的值。
位置参数的数量在函数定义时是确定的，调用时必须提供相同数量的参数值。

下面是使用位置参数的示例：

def greet(name, age):
    print(f"Hello, {name}! You are {age} years old.")

greet("Alice", 25)  # 输出：Hello, Alice! You are 25 years old.

在上面的例子中，greet() 函数定义了两个位置参数 name 和 age。在调用函数时，按照位置的顺序传递参数值，即 "Alice" 和 25。函数内部会根据参数的位置将参数值分别赋给对应的参数名称，然后执行函数体内的代码。

需要注意的是，调用函数时，位置参数的顺序必须与函数定义中的参数顺序一致，否则会导致参数值与参数名称不匹配的错误。

另外，可以在函数定义时为位置参数提供默认值，这样在函数调用时可以选择性地省略这些参数。例如：

def greet(name, age=30):
    print(f"Hello, {name}! You are {age} years old.")

greet("Bob")  # 输出：Hello, Bob! You are 30 years old.
greet("Charlie", 35)  # 输出：Hello, Charlie! You are 35 years old.

在上面的例子中，greet() 函数的第二个参数 age 设置了默认值为 30。当省略第二个参数时，将使用默认值 30。当提供第二个参数时，将使用提供的参数值。

通过使用位置参数，我们可以根据参数的位置来传递参数值，灵活地定义和调用函数，并根据需要提供默认值。

Python21天打卡Day20-可变参数、关键字参数

在 Python 中，可变参数允许函数接受任意数量的参数。这些参数被封装成一个元组（Tuple）或列表（List），并作为参数传递给函数。

Python 中有两种类型的可变参数：

*args：用于传递可变数量的位置参数（Positional Arguments）。
**kwargs：用于传递可变数量的关键字参数（Keyword Arguments）。

下面是使用可变参数的示例：

使用 *args 接收可变数量的位置参数：

def sum(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum(1, 2, 3))  # 输出：6
print(sum(4, 5, 6, 7))  # 输出：22

在上面的例子中，sum() 函数定义使用了 *args 参数，它可以接受任意数量的位置参数。在函数体内，使用循环将传递的参数加总，并返回总和。

使用 **kwargs 接收可变数量的关键字参数：

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(key + ": " + value)

print_info(name="Alice", age="25", city="New York")

在上面的例子中，print_info() 函数定义使用了 **kwargs 参数，它可以接受任意数量的关键字参数。在函数体内，通过遍历 kwargs 字典的键值对，按照指定的格式打印出参数的名称和值。

def func(x,**kwargs):
    print(x)
    print(kwargs)
    print('总共有%d个参数'%len(kwargs))
    print('这些参数分别为:',kwargs)
func(20,name='rose',age=18)

D:\学习\Python工程\venv\Scripts\python.exe D:/学习/Python工程/practice/test_demo.py
20
{'name': 'rose', 'age': 18}
总共有2个参数
这些参数分别为: {'name': 'rose', 'age': 18}

Process finished with exit code 0

使用可变参数可以使函数更加灵活，能够接受不固定数量的参数。同时，还可以与固定参数一起使用，例如结合位置参数和可变参数，或结合关键字参数和可变参数。需要根据具体的需求来选择合适的参数类型与组合方式。

python21天打卡Day21-函数装饰器

利用装饰器来装饰函数，我们可以在避免重复代码、保持代码逻辑隔离的前提下添加新的功能

函数的几个特征要点：

1）函数是一种对象类型，从这个层面上来看，函数和字符串没有太大差别。

2）在Python（以及其他一些高级编程语言）里，函数不仅可以接受传递给它的参数，它本身也可以作为参数传递给其他函数，也可以作为函数返回值。

3）我们可以在函数里定义函数，即内嵌函数。

from datetime import datetime
def log_time():
print(“现在时间为{}”.format(datetime.now()))
def bye(name):
print(“拜拜{}”.format(name))
log_time()

def greet(name):
print(“Hello{}”.format(name))
log_time()
greet(“susan”)
bye(“susan”)

对于上面这段代码，在每个函数里调用了log_time。

这在代码层面是可以工作的，但是在设计上是有明显问题的。因为函数的设计应该是专注于它应该完成的核心任务，打印执行的日期显然不是它的“核心竞争力”，我们不应该把这样的代码直接加到它的函数体内，否则会有两个问题：

1）业务逻辑混乱，因为打印执行日期不是这个函数本身要完成的目标，而相应的代码却被加进函数体内了。

2）如果需求有变更，后续不需要打印执行日期了，我们需要到每个函数体内去把相应的代码删除，代价比较大。

函数装饰器可以改善这个设计。

函数装饰器有三个特征：

它本身是一个函数。

它接受且只接受一个参数，这个参数也是一个函数。

它返回一个函数。

from datetime import datetime

def function_time_logger(func):
def wrapper():
func()
print(“现在时间为{}”.format(datetime.now()))
return wrapper

def bye():
print(“拜拜”)

def greet():
print(“Hello”)

time_greet=function_time_logger(greet)
time_bye=function_time_logger(bye)
time_greet()
time_bye()

在这个例子里，function_time_logger就是一个函数装饰器，它装饰了另外一个函数，而被它装饰的函数无须知道它的存在。上面范例中的调用方法比较麻烦，Python提供了更加简洁的语法，让我们可以更加容易地“装饰”

from datetime import datetime

def function_time_logger(func):
def wrapper():
func()
print(“现在时间为{}”.format(datetime.now()))
return wrapper

def bye():
print(“拜拜”)

@function_time_logger
def greet():
print(“Hello”)

greet()
bye()

在上面的例子中，我们必须把bye和greet两个函数的参数列表设置为空，没有带参数，因为函数装饰器“接受且只接受一个函数类型的参数”，我们无法把函数的参数带给函数装饰器。

那么如何带参数呢？

让装饰器只接受一个参数（一个函数对象），但是装饰器的内嵌函数参数列表用可变参数

from datetime import datetime

def function_time_logger(func):
def wrapper(*args,**kwargs):
func(*args,**kwargs)
print(“现在时间为{}”.format(datetime.now()))
return wrapper

@function_time_logger
def bye():
print(“拜拜”)

@function_time_logger
def greet(name):
print(“Hello{}”.format(name))

greet(“susan”)
bye()

装饰器可以让我们对函数进行装饰，添加附加的功能。

Property装饰器
@property是Python内置的一个函数装饰器，它可以让类的一个（或者一组）成员方法使用起来就像成员变量一样方便

正常情况下，我们对属性赋值，直接赋值就可以了：

class People(object):
def init(self, name, age):
self.name = name
self.age = age

p1 = People(‘张三’, 22)
p1.name = ‘李四’
print(p1.name)

输出为李四

但是如果我们对所赋的值有一定的限制，比如要求名字必须是字符串，年龄必须是数字，否则会对方法的调用造成影响，这个时候单纯的赋值就不能满足这样的过滤效果了。

最常见的做法是把成员变量设置为私有，然后提供相应的getter和setter函数，在setter函数里做检查，筛查非法的赋值，避免非法的值被代入系统。

使用的时候是这样的：

p1 = People(‘张三’, 22)
p1.set(‘李四’)
print(p1.getName());
这样其实已经可以了，很满足功能需要。而用@property是让这个更简洁，既保持直接对属性赋值的方便，又对条件做了限制

class People(object):
def init(self, name, age):
self.name = name
self.age = age

@property
def name(self):
    a = self._name
    # 返回前还可以对数据做处理，比如格式化等
    return a

@name.setter
def name(self, value):
    # 在赋值之前添加判断
    if not isinstance(value, str):
        # 抛出异常
        raise TypeError('People object.name,name must be a str!')
    self._name = value

调用的时候仍然是方便快捷的直接赋值：
p1 = People(‘张三’, 22)
p1.name = ‘李四’
print(p1.name)

如没有使用装饰器前

from datetime import date
class Student:
def init(self,name):
self.name=name
self.__birth_year=date.today().year-6

def get_birth_year(self):
    return self.__birth_year

def set_birth_year(self,new_year):
    if new_year>date.today().year:
        print("too young!")
        return
    self.__birth_year=new_year

s1=Student(“susan”)
print(s1.get_birth_year())

s1.set_birth_year(2019)
print(s1.get_birth_year())

s1.set_birth_year(2030)
print(s1.get_birth_year())
使用了装饰器后

from datetime import date
class Student:
def init(self,name):
self.name=name
self.__birth_year=date.today().year-6

@property
def birth_year(self):
    return self.__birth_year

@birth_year.setter
def birth_year(self,new_year):
    if new_year>date.today().year:
        print("too young!")
        return
    self.__birth_year=new_year

s1=Student(“susan”)
print(s1.birth_year)

s1.birth_year=2019
print(s1.birth_year)

s1.birth_year=2030
print(s1.birth_year)

可以直接用等号进行赋值。