记录学习Python-100天从0到1（2）

最新推荐文章于 2024-04-17 18:30:00 发布

c0ld1nk

最新推荐文章于 2024-04-17 18:30:00 发布

阅读量117

点赞数

分类专栏： python学习文章标签：学习 python 数据结构

本文链接：https://blog.csdn.net/m0_74160536/article/details/129840396

版权

python学习专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Day 3：分支结构

1.Python中没有用花括号来构造代码块而是使用了缩进的方式来表示代码的层次结构

即连续的代码如果又保持了相同的缩进那么它们属于同一个代码块（能使用扁平化的结构时就不要使用嵌套）

2.语法结构：

if condition1：

elif condition2：

else：

Day 4：循环结构

1.语法结构：

#for-in循环
for x in range(101)：#从0循环到10
for x in range(1，101):#从1到100
for x in range(1，101，2):#从1到100，每次增加2
range(100，0，-2):#100到1，递减，生成偶数
#while循环
while():

2.附带知识：

x,y = y,x #交换x，y值

Day 5：构造程序逻辑（略过）

Day 6：函数

1.定义函数 def name（参数）

2.函数参数：可以为def a(n=2),即设定一个初值，若使用函数时没有参数，则使用初值；当不确定初值个数时，使用“*”+变量来表示可变变量。

def add（*args）：
        Total=0
        For val in args：
        Total += val

参数作用域：“局部作用域”、“嵌套作用域”、“全局作用域”和“内置作用域”

在函数外定义就是全局，函数内为局部，函数内的函数为嵌套

若是想在函数内修改局部变量，使用global关键字，使用nonlocal关键字来使用嵌套关键字

规范函数使用如下：

def main():
    # Todo: Add your code here
    Pass（pass只是占位符）
if __name__ == '__main__':
    main()

Day 7：字符串和常用数据结构

1.使用‘’和“”都可以表示字符串，而\用来表示转义（\n,\t,\\,\’），也可以用来进行进制转换（\x61->a）

如果不希望进行转义，可以在前面添加’r‘

2.使用 + 来进行字符串链接，用*来进行重复字符串，in /not in 来判断是否包含某一字符（返回布尔值）

3.使用[]和[:]来切片，如：：

str = '1234567'
print(str[2]) #从下标2取出（从0开始算）
print(str[2:5]) #从下标2开始进行取出，到5结束（不包括5）
print(str[0::2]) #从0开始，每隔两个切片
print(str[::-1])#从后面往前面切片
print(str[-3:-1]) #从-3到-1切片

结果：

3
345
1357
7654321
56

4.常用函数：

    str1 = 'hello, world!'
    # 通过内置函数len计算字符串的长度
    print(len(str1)) # 13
    # 获得字符串首字母大写的拷贝
    print(str1.capitalize()) # Hello, world!
    # 获得字符串每个单词首字母大写的拷贝
    print(str1.title()) # Hello, World!
    # 获得字符串变大写后的拷贝
    print(str1.upper()) # HELLO, WORLD!
    # 从字符串中查找子串所在位置
    print(str1.find('or')) # 8
    print(str1.find('shit')) # -1
    # 与find类似但找不到子串时会引发异常
    # print(str1.index('or'))
    # print(str1.index('shit'))
    # 检查字符串是否以指定的字符串开头
    print(str1.startswith('He')) # False
    print(str1.startswith('hel')) # True
    # 检查字符串是否以指定的字符串结尾
    print(str1.endswith('!')) # True
    # 将字符串以指定的宽度居中并在两侧填充指定的字符
    print(str1.center(50, '*'))
    # 将字符串以指定的宽度靠右放置左侧填充指定的字符
    print(str1.rjust(50, ' '))
    str2 = 'abc123456'
    # 检查字符串是否由数字构成
    print(str2.isdigit())  # False
    # 检查字符串是否以字母构成
    print(str2.isalpha())  # False
    # 检查字符串是否以数字和字母构成
    print(str2.isalnum())  # True
    str3 = '  jackfrued@126.com '
    print(str3)
    # 获得字符串修剪左右两侧空格之后的拷贝
    print(str3.strip())

结果：

13
Hello, world!
Hello, World!
HELLO, WORLD!
8
-1
False
True
True
******************hello, world!*******************
hello, world!
False
False
True
jackfrued@126.com
jackfrued@126.com

5.格式化输出：

a, b = 5, 10
print('%d * %d = %d' % (a, b, a * b))
print('{0} * {1} = {2}'.format(a, b, a * b))
print(f'{a} * {b} = {a * b}')

结果：

5 * 10 = 50
5 * 10 = 50
5 * 10 = 50

6.列表：(1) 创建与测量长度：

listname1 = [1,'w','hee']
listname2 = ['hello']*3
#可用下标索引，负数代表从后面开始
print(len(listname1))#测量长度
print(len(listname2))
"""
结果：
3
3
"""

（2）三个循环列表的方式：

# 通过循环用下标遍历列表元素
for index in range(len(list1)):
    print(list1[index])
# 通过for循环遍历列表元素
for elem in list1:
    print(elem)
# 通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值
for index, elem in enumerate(list1):
    print(index, elem)

（3）列表操作：

    list1 = [1, 3, 5, 7, 100]
    # 添加元素
    list1.append(200)
    list1.insert(1, 400)
    # 合并两个列表
    # list1.extend([1000, 2000])
    list1 += [1000, 2000]
    print(list1) # [1, 400, 3, 5, 7, 100, 200, 1000, 2000]
    print(len(list1)) # 9
    # 先通过成员运算判断元素是否在列表中，如果存在就删除该元素
    if 3 in list1:
        list1.remove(3)
    if 1234 in list1:
        list1.remove(1234)
    print(list1) # [1, 400, 5, 7, 100, 200, 1000, 2000]
    # 从指定的位置删除元素
    list1.pop(0)
    list1.pop(len(list1) - 1)
    print(list1) # [400, 5, 7, 100, 200, 1000]
    # 清空列表元素
    list1.clear()
    print(list1) # []

（4）列表切片：

    fruits = ['grape', 'apple', 'strawberry', 'waxberry']
    fruits += ['pitaya', 'pear', 'mango']
    # 列表切片
    fruits2 = fruits[1:4]
    print(fruits2) # apple strawberry waxberry
    # 可以通过完整切片操作来复制列表
    fruits3 = fruits[:]
    print(fruits3) # ['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
    fruits4 = fruits[-3:-1]
    print(fruits4) # ['pitaya', 'pear']
    # 可以通过反向切片操作来获得倒转后的列表的拷贝
    fruits5 = fruits[::-1]
    print(fruits5) # ['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape']

（5）列表排序：

    list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
    list2 = sorted(list1)
    # sorted函数返回列表排序后的拷贝不会修改传入的列表
    # 函数的设计就应该像sorted函数一样尽可能不产生副作用
    list3 = sorted(list1, reverse=True)
    # 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
    list4 = sorted(list1, key=len)
    print(list1)#['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
    print(list2)#['apple', 'blueberry', 'internationalization', 'orange', 'zoo']
    print(list3)#['zoo', 'orange', 'internationalization', 'blueberry', 'apple']
    print(list4)#['zoo', 'apple', 'orange', 'blueberry', 'internationalization']
    # 给列表对象发出排序消息直接在列表对象上进行排序
    list1.sort(reverse=True)
    print(list1)#['zoo', 'orange', 'internationalization', 'blueberry', 'apple']

（6）列表生成器：

    f = [x for x in range(1, 10)]
    print(f)#[1, 2, 3, 4, 5, 6, 7, 8, 9]
    f = [x + y for x in 'ABCDE' for y in '1234567']
    print(f)
    #['A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'D1', 'D2', 'D3', 'D4', 'D5', 'D6', 'D7', 'E1', 'E2', 'E3', 'E4', 'E5', 'E6', 'E7']
    # 用列表的生成表达式语法创建列表容器
    # 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
    f = [x ** 2 for x in range(1, 1000)]
    print(sys.getsizeof(f))  # 查看对象占用内存的字节数 8856
    print(f)
    # 请注意下面的代码创建的不是一个列表而是一个生成器对象
    # 通过生成器可以获取到数据但它不占用额外的空间存储数据
    # 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)
    f = (x ** 2 for x in range(1, 1000))
    print(sys.getsizeof(f))  # 相比生成式生成器不占用存储数据的空间 104
    print(f)
    for val in f:
        print(val)

（7）使用yield关键字将函数改造成生成器（下图为生成一个斐波那契数列列表）

    def fib(n):
        a, b = 0, 1
        for _ in range(n):
            a, b = b, a + b
            yield a
    def main():
        for val in fib(20):
            print(val)
    if __name__ == '__main__':
        main()

7.元组：将多个不同类型的元素组合在一起，特点是不可被改变

（1）创建：

t = (1,2,"ss")#创建元组
list(t)#元组转换为列表
tuple(t)#列表转换为元组

（2）当不需要对元素更改时，或者一个方法返回多个值，使用元组；元组的创建时间和占用空间都要优于列表；

8.集合：性质和数学上一致；

（1）创建：

s = {}#创建
s = set（range（1，10））#创建集合的构造器语法
s = { num for num in range(1,100) if num %3==0 or num %5==0 }#创建集合的推导式语法

（2）增减元素：

t.add()#增加元素
t.update([10,11])#增加10和11
t.remove()#移除元素
t.discard()#移除元素
t.pop()#移除最后一个元素

(3)集合运算：

    # 集合的交集、并集、差集、对称差运算
    print(set1 & set2)
    # print(set1.intersection(set2))
    print(set1 | set2)
    # print(set1.union(set2))
    print(set1 - set2)
    # print(set1.difference(set2))
    print(set1 ^ set2)
    # print(set1.symmetric_difference(set2))
    # 判断子集和超集
    print(set2 <= set1)
    # print(set2.issubset(set1))
    print(set3 <= set1)
    # print(set3.issubset(set1))
    print(set1 >= set2)
    # print(set1.issuperset(set2))
    print(set1 >= set3)
    # print(set1.issuperset(set3))

9.字典：

（1）创建

s = {‘xx’:99,’x’:55}#创建
t = dict(one=1,two=2,three=3)
i = dict(zip([‘a’,’b’,’c’],’123’))#zip函数，将字符串和列表变成字典，结果为  a:1,b:2,c:3
i = {num:num**2 for num in range(1,10)}#推导式语法

（2）一些操作：

for key in i#遍历键
t.update(key = new)#更新字典
t.get(key,a)#若没有，输出a的值
t.popitem()#删除
t.pop(key)#删除
t.clear#清空

10.enumerate（）：将列表，元组或字符组合成一个索引序列，同时列出数据和数据下标，如：

balls = (1,5,88,5)
for index, ball in enumerate(balls):
                print(index,ball)

#结果：0 1;1 5;2 88;3 5

c0ld1nk

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录