百人计划-21天python打卡

这里我会放一些我在打卡过程中遇到的一些小问题

问题1：在编写Python时，当使用中文输出或注释时运行脚本，会提示错误信息：SyntaxError: Non-ASCII character ‘\xe5’ in file *******
原因：python的默认编码文件是用的ASCII码，你将文件存成了UTF-8
解决方法：在文件开头加上# -- coding: UTF-8 -- 或者 #coding=utf-8
问题2：Mac升级后一直提示/usr/bin/env:python:No such file or directory : )，说在环境变量找不到python，升级之前使用都是正常的，于是我又重新安装了一遍，命令行输入“apt-get install python3
”，等待下载安装即可，安装完成再修改pycharm的路径就不会再报错了。

Day1: 准备环境

​ 准备Python环境，命令行输入Python，输出版本号即可

Day2：下载pycharm

​ 下载pycharm社区版本(官网下载就行了，社区版也是免费的，打卡使用肯定够了)

Day3: 建立常见数据类型

​ 建立几种常见的数据类型，包含 int/float/string/list/tuple/dict等

"""
number(数字)
string(字符串)
list(列表)
tuple(元组)
set(集合)
dictionar(字典)
float(浮点)
bytes(字节)

不可变数据：number、string、tuple
可变数据：list、dictionary、set
"""

# int
a = 100
# float
b = 100.0
# string
c = "I love the Python"
# list
d = [03, "liebiao",03,"list"]
# tuple
d = (03, "yuanzu",03,"tuple")
# dic
e = {"location":"shunyi","city":"beijing","age":25}

Day4:对string数据进行截断/链接/复制

​ 对于string数据，进行数据的截断/字符串的连接/复制当前的字符串data_string = “21 day python”

​ 1.截断(切片)：data_string[:]、data_string[1:9]、data_string [:-1]、data_string [0:]、data_string [::-1]
​ 2.连接：data_string =“hello world”
​ 3.复制当前字符串 ：data_string*2
​ 4.占位符：(“%S”%data_string )

分别写出data_string 进行上述操作后的值

data_string = "21 day python"  #定义一个字符串

print (data_string[:])  # 得到所有字符
print (data_string[1:9])  # 输出第2-8位的字符（左闭右开）
print (data_string[:-1])  # 输出最后一位之前的所有字符
print (data_string[0:])  # 输出第一位及以后的所有字符
print (data_string[::-1])  # 输出所有字符并按照倒叙排列
print (data_string + "hello world")  # 字符串拼接
print (data_string*2)  # 复制当前字符串
print ("string=%s" % data_string)   # 占位符"%S"

Day5: 对list类型数据进行索引/切片/列表赋值

​ 对于list类型数据，进行数据的索引/切片/列表的连接/对列表的赋值，列表可以完成大多数集合类的数据结构实现。它支持 字符、数字、字符串甚至可以包含列表（所谓嵌套）

data_list = [21, “day”, “python”]

​ 1.索引：data_list[0]、data_list[1]
​ 2.切片：data_list[-1]、data_list[::-1]
​ 3.列表的连接data_list.append(“hello world”)
​ 4.对列表的赋值：data_list*2、data_list[1:2] = “may”、data_list[1:2] = [“may”]

分别写出data_list数据进行上述操作后的值分别为多少

# coding=utf-8

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")   # append:附加。在列表data_list中加上字符串"hello world"
print (data_list)
# 赋值
print (data_list*2)
data_list[1:2] = "may"  # 将列表中第二个数据(day)赋值为单个字符串may
print (data_list)
data_list[1:2] = ["may"]    # 将列表中第二个数据(day)赋值为集合字符串may
print (data_list)

Day6: 对tuple类型数据进行数据索引/切片/拆包

对于 tuple类型数据，进行数据索引/切片/包含1个元素的元组/元组的拆包

data_tuple = (21, “day” , “python”)
1.索引：data_tuple[0]、data_tuple[-1]
2.切片：data_tuple[:-1]、data_tuple[::-1]
3.写出包含一个元素的元组
4.拆包：data_1,data_2,data_3=data_tuple,data_1,data_2,data_3分别返回什么值
5.元组和列表的区别

# coding=utf-8
data_tuple = (21, "day", "python") # 定义一个元组
# 索引
print data_tuple[0]  # 输出元组中第一个数据
print data_tuple[-1]  # 输出元组中最后一个数据
# 切片
print (data_tuple[:-1])  # 输出元组中第1-2个数据
print (data_tuple[::-1])  # 输出元组中所有数据并倒序沾水
# 写出包含一个元素的数组
data_tuple1 = ("one",) # 定义一个元组
print (type(data_tuple1))  # 输出类型
print (len(data_tuple1))   # 输出长度
# 延伸
data_tuple1 = ("one") # 定义一个字符串
print (type(data_tuple1))  # 输出类型
print (len(data_tuple1))   # 输出长度
# 拆包
data_1,data_2,data_3 = data_tuple # 将元组data_tuple中的数据拆分为1、2、3并输出
print (data_1)
print (data_2)
print (data_3)

Day7: 对dict类型数据进行访问/修改/删除

对于dict类型数据，进行访问字典内的值/修改字典/删除字典的元素
data_dict = {“location”:“shunyi”,“city”:“beijing”,“age”:25}z
1.访问字典内的值data_dict[“age”]
2.修改字典data_dict[‘sex’] = 1
3.删除字典del data_dict[‘sex’]

# coding=utf-8

data_dict = {"location":"shunyi","city":"beijing","age":25}  # 定义一个字典
print (data_dict["age"]) # 输出字典中age的值
# 修改字典中age和location的值并输出
data_dict ["age"] = 26
data_dict ["location"] = "haidian"
data_dict ["sex"] = 1 # 此处新增一个sex
print (data_dict)
# 删除字典
del data_dict['sex']
print data_dict

Day8: string和int类型互转

string和int类型互转，分别写出下面几种场景下的代码
1.string类型转int，a = “21”
2.10进制string转换成int
3.16进制string 转换成int
4.int类型转string

# coding=utf-8

# string转int
"""
int(x,base=10)  函数用于将某个数据类型(如字符串、浮点)转化成整数
base参数默认是10，代表传入的x是十进制，由于位置的原因，base是第二个参数，所以在赋值的时候不用写base=，可以直接写数字，数字是几就是几进制数
"""
a = "21"  # 定义一个string类型的数据
print("10进制string'21'转换成int是:%d" % int(a))
print("16进制string'21'转换成int是:%d" % int(a, 16))


# int转string
'''str()用于将非字符串类型的数据转换成字符串'''
a = 21  # 定义一个int类型的数据
print("int21转换成10进制的string是:" + str(a))
'''hex()用于将10进制整数转换为16进制，以字符串形式表示'''
print("int21转换成16进制string是:" + hex(a))

Day9: string和dict类型互转

string和dict类型互转，分别写出下面几种场景的代码
1.string类型转dict，转换完后检查数据类型是否修改
a = “{‘name’:‘chenwanyu’,‘sex’:‘women’,‘age’:‘25’}”

2.dict类型转string，转完后检查数据类型是否修改
a = {‘name’:‘chenwanyu’,‘sex’:‘women’,‘age’:‘25’}

# coding=utf-8
"""
eval()函数用来执行一个字符串表达式，并返回表达式的值
语法：eval(expression[,globals[,locals]])
参数说明：
expression--表达式
globals--变量作用域，全局命名空间，如果被提供，则必须是一个字典对象
locals--变量作用域，局部命名空间，如果被提供，可以是任何映射对象
"""
# 定义一个string类型的数据
a1 = "{'name':'chenwanyu','sex':'women','age':'25'}"
print("a1的类型{}".format(type(a1)))   # 输出a1的类型
b1 = eval(a1)  # 转换string a1 为dict b1
print("b1的类型{}".format(type(b1)))  # 输出b1的类型
print(b1)  # 输出被转换后的数据


"""
str()函数将对象转换成适于人阅读的形式
语法：str(object)
参数说明：object--操作对象
"""
# 定义一个dict的数据
a2 = {'name':'chenwanyu','sex':'women','age':'25'}
print("a2的类型{}".format(type(a2)))  # 输出a2的类型
b2 = str(a2)  # 转换dict a2 为string b2
print("b2的类型{}".format(type(b2)))
print(b2)

Day10: string和bytes类型互转

string和bytes类型互转，分别写出下面几种场景下的代码
1.string类型转bytes【utf-8格式】，转完后检查数据类型是否修改
a = “21 python”
2.bytes类型【utf-8格式】转string，转完后检查数据类型是否修改
a = b’21 python’

# coding=utf-8
# 字符串是以字符为单位进行处理的，bytes类型是以字节为单位进行处理的
"""
b = bytes()  # 创建1个空的bytes
b = b'hello'  # 指定hello是bytes类型
b = str.encode('编码类型') # 利用字符串的encode方法编码成bytes，默认为utf-8类型
b = bytes.decode('编码类型')：将bytes对象解码成字符串，默认使用utf-8进行解码。
"""

#  string转bytes
a1 = "21 python"   # 定义string类型的a1
print("a1的类型{}".format(type(a1)))  # 输出a1的类型
b1 = str.encode(a1)   # b = str.encode(a)    直接以默认的utf-8编码string为bytes（转换string a 为types b）
print("b1的类型{}".format(type(b1)))  # 输出b1的类型

# bytes转string
a2 = b'21 python' # 定义types类型的a2
print("a2的类型{}".format(type(a2)))   # 输出a2的类型
b2 = bytes.decode(a2) # b = types.decode(a)   以默认的utf-8编码解码bytes成string
print("b2的类型{}".format(type(b2)))  # 输出b2的类型

Day11:dict和json 格式互转

dict和json格式互转，分别写出下面几种场景下的代码
1.dict类型转json，转完检查数据类型是否修改
a = {‘name’:‘chenwanyu’,‘sex’:‘women’,‘age’:25}
2.json类型转dict，转完检查数据类型是否修改
a = ‘{“name”: “chenwanyu”, “sex”: “women”, “age”:25}’

# coding=utf-8
"""
loads():将json数据转化成dict数据
dumps():dict转json
load():读取json文件数据，并转换成dict
dump():将dict数据转换成json后，写入json文件
"""
# dict转json
import json
a1 = {'name': 'chenwanyu', 'sex': 'women', 'age': 25}
b1 = json.dumps(a1)
print(b1)
print("b1的数据类型{}",format(type(b1)))

# json转dict
a2 = '{"name": "chenwanyu", "sex": "women", "age":25}'
b2 = json.loads(a2)
print("b2:", b2)
print(type(b2))

Day12:分别使用for循环和列表推导式构建一个1-100的列表

# for循环
a1 = []
for i in range(1, 101):
    a1.append(i)
    print("a1:",a1)

# 推导式
a2 = [i for i in range(1, 101)]
print("a2:", a2)

Day13：写出一个生成器表达式，并检查所写的类型

# coding=utf-8

''' 
生成器表达式
语法：(返回值 for 元素 in 可迭代对象 if条件) 
'''
generator = (i**2 for i in range(5)) # 定义一个生成器
print("生成器对象为:{}，类型为:{}".format(generator,type(generator))) # 输出其类型

# 判断一个可迭代对象是否是迭代器，通过next方法，迭代一个迭代器对象
print(next(generator))
# 判断一个列表是否为迭代器
try:
    list = [i**2 for i in range(5, 6)]
    print(next(list))
except Exception as e:
    print(e)  # 走到这一步，输出列表不是迭代器
finally:   # 可以通过iter方法把一个可迭代对象封装成迭代器
    i = iter(list)
    print(next(i))

Day:14 生成随机字符串/数字

1.写出6位包含大小写在内的随机字符串
2.写出8位包含数字的随机数字

# coding=utf-8

"""
知识点1：
1、ascii_letters方法的作用是生成全部字母，包括a-z,A-z
2、digits方法的作用是生成数组，包括0-9
    a = string.ascii_letters
    b = string.digits
    print(a)    #输出abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
    print(b)    #输出0123456789
知识点2：
1、random.sample():从指定序列中随机获取指定长度的片段并随机排列，不会修改原数列
    list=(1,2,3,4,5)
    num = random.sample(list,2)
    print(num)  # 随机获取list中2位数字
2、join()函数用于指定分隔符
    string =  "test"
    list = ['a','b','c']
    print("10".join(string))  # 指定10为test的分隔符，输出结果t10e10s10t
    print("".join(list))    # 输出结果abc
    print(" ".join(list))  # 指定空格为list的分隔符，输出结果 a b c
"""
import random
import string

a = "".join(random.sample(string.ascii_letters, 6))
b = "".join(random.sample(string.digits, 8))
print(a)
print(b)

Day15:编写一个阶乘函数

今天的题对我来说有点难，看了比较多的文章才写出来的，有的也不是特别理解，放到这里仅供参考

# coding=utf-8

""" 方法一：for循环 """
import math

a = int(input('please inputer a integer:'))  # 提示用户输出一个整数
num1 = 1
if a < 0:
    print('负数不支持阶乘')
elif a == 0:
    print('0的阶乘为1')
else:
    for i in range(1, a + 1):  # 给i赋值，范围为1——a+1,不含a+1
        num1 *= i  # *=含义：b *= a--->b = b*a
    print(num1)

"""方法二：reduce()函数"""
from functools import reduce  # 从functools中调取reduce()函数


num2 = reduce(lambda x, y: x * y, range(1, 6))  # 使用lambda匿名函数，迭代
print(num2)

"""方法三：递归函数"""


def num3(n):
    if n == 0:
        return 1
    else:
        return n * num3(n - 1)


print(num3(5))

"""方法四:numpy库"""
import numpy

print(numpy.math.factorial(5))

"""方法五：python自带的标准库"""
import math

print(math.factorial(5))
#   或者写成 :
# num5 = math.factorial(5)
# print(num5)

这几天有点忙，都没更新，如果有人看的话，先贴一些题目吧

Day16:map函数

​ map()会根据提供的函数对指定的序列做映射，即将函数一次作用在列表中的每一个元素上，形成一个新的列表。将列表[1,2,3,4,5]中的每个元素都平方

# 将列表中每个元素都平方
a = [1, 2, 3, 4, 5]


#  方法1：创建函数后，在map()引用
def square1(n):
    return n ** 2


b = list(map(square1, a))
print(b)
#  或者：print(list(map(square1, a)))


#  方法2：map()内，直接创建lambda匿名函数
c = list(map(lambda x: x ** 2, a))
print(c)

note：python3中，map函数返回的是一个map对象，需要list(map(fun,itor))来将映射后的map对象转换成list

# 类型转换示例
# 1.元祖转list
print(list(map(int, (1, 2, 3))))  # 输出结果[1,2,3]

# 2.序列元素类型转换
print(tuple(map(str, [1, 2, 3])))  # 输出结果('1', '2', '3')

# 3.字符串转list（字符串作为可迭代对象，每次迭代取1个字符）
print(list(map(str, "chenwanyu")))  # 输出结果['c', 'h', 'e', 'n', 'w', 'a', 'n', 'y', 'u']

# 4.字符串转tuple
print(tuple(map(str,"chenwanyu")))  # 输出结果 ('c', 'h', 'e', 'n', 'w', 'a', 'n', 'y', 'u')

# 5.字典key存储到list
print(list(map(str, {"name": "chenwanyu","sex": "female", "age": "18"}))) #输出结果['name', 'sex', 'age']

Day17:filter函数

filter()函数用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新列表
找出列表[1,2,3,4,5,6,7,8.9,10]中的奇数

# coding=utf-8
"""
filter()函数用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新列表
filter()函数是python内置的另一个有用的高阶函数，filter()函数接收一个函数f和一个list，这个函数f的作用是对每个元素进行判断，返回true或者false
"""

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


def f(n):
    if n % 2 == 1:
        return True
    else:
        return False


new = list(filter(f, a))
print(new)

Day18:lambda函数

使用lambda函数将列表[1,2,3,4,5]中的每个元素都平方

# coding=utf-8
"""

使用lambda函数将列表[1,2,3,4,5]中的每个元素都平方

lambda函数语法：(作用：用户自定义一个匿名函数)
    lambda函数语法 argument_list:expression
参数：
    lambda:python预留的关键字
    argument_list：参数列表
    expression：对应argument_list参数的表达式
"""

a = [1, 2, 3, 4, 5]
# map()返回一个迭代器
b = map(lambda n: n ** 2, a)
print(list(b))  # map函数返回的是一个map对象，需要list(map(fun,itor))来将映射后的map对象转换成list

Day19:计算函数值01

1.位置传参是最简单的传入参数的方式
def func(a,b):
print(a+b)
func(1,2)
2.默认参数表示在调用函数的时候使用一些包含默认值的参数，默认值的参数也可覆盖
def func(a,b=2)
print(a+b)
func(1)
func(1,4)
分别写出函数的值是多少

# coding=utf-8
"""
自定义函数中，给默认值时：没传参会用默认值执行后续操作，若传参则顶替默认值
"""


# 位置传参
def func(a, b):  # a,b是形参。仅在定义的函数中有效，函数调用结束后，不能再使用该形参变量
    print("a:", a, "b:", b)
    print("无默认值传参：", a + b)


func(1, 6)  # a=1，a=6,此时a+b=7


# 参数默认值
def func(a, b=4):  # b是实参。在调用函数时，向该函数的形参传递确定的值（必须是确定的值）。传递的值可以是常量、变量、表达式、函数等形式~
    print("a:", a, "b:", b)
    print("有默认值传参：", a + b)


func(2)  # a=2,b=4,此时a+b =6
func(1, 5)  # a=1,b被替换为5，此时a+b =6

Day20:计算函数值02

可变参数允许在调用参数的时候传入多个(≥0个)参数(类似于列表、字典)
def func(args):
print(args)
print(args[0])
func(‘P’,‘y’,‘t’,‘h’,‘o’,‘n’)
func(‘Python’,123,‘爬虫’)
func((1,2,3)
分别写出函数的值是多少

def func(*args):
    print(args)  # 打印所有参数
    print(args[0])  # 打印参数中第一个元素


func('p', 'y', 't', 'h', 'o', 'n')
func('python', '123', "爬虫")
func(*(1, 2, 3))

# 输出
('p', 'y', 't', 'h', 'o', 'n')
p
('python', '123', '爬虫')
python
(1, 2, 3)
1

Day21:计算函数值03

关键字参数允许在调用时以字典形式传入0个或多个参数
def func(x, **kwargs):
print(x)
print(kwargs)
print(‘总共有%d个参数’%len(kwargs))
print(‘这些参数分别为:’,kwargs)
func(20,name=‘rose’,age=18)
分别写出函数的值是多少

#coding=utf-8
"""
关键字参数允许在调用时，以字典形式传入0个或多个参数
"""

def func(x, **kwargs):  # 2.进入函数  // ** 的作用是把字典kwargs变成关键字参数传递
    print(x)
    print(kwargs)  # 3.这一步和后面2步是，接收的关键字参数打印、封装进字典的元素个数
    print('总共有%d个参数' % len(kwargs))
    print('这些参数分别为：', kwargs)


func(18, name='rose', age=20)  # 1.调用函数，传关键字参数

#输出结果可以看到已经封装为dict，2对键值对
20
{'name': 'rose', 'age': 18}
总共有2个参数
这些参数分别为： {'name': 'rose', 'age': 18}

---

有些不会的先敲一遍，再查找资料慢慢理解一下就好了，我是这么安慰自己反正。如果有人在看的话，希望你们也都能坚持下来哇，有什么问题可以讨论。我先去搞下一个啦。