python学习笔记Day2 循环结构，循环嵌套，列表，字典，元组

python学习笔记Day2 循环结构，循环嵌套，列表，字典，元组 一、range函数

三种创建方式：

一、range(10) 默认从0开始，默认步长为1，所以是0-9

二、range(1,10) 第一个参数为开始值，第二个结束值，表示1-10

三、range(1,10,2)最后一个参数为步长，表示1，3，5，7，9

返回一个迭代器对象

优点不管你的range对象表示的整数序列有多长，占用的内存空间相同，因为只需要存储起始值，结束值，步，只有用到range对象才会计算其对应整数序列。

二、循环结构 一、while循环

0到100偶数和：

sum=0
a=0 #初始化变量
while a<=100: #条件判断
sum+=a #条件执行体
a+=2
print(sum)

二、for

for item(别名) in 'python'(可迭代对象):

print(item)

1到100偶数和：

sum = 0
for i in range(1,101):
    if i % 2 == 0:
        sum += i
print(sum)

100到999之间的水仙花数：

sum = 0
for i in range(100, 1000):
    for item in str(i):
            sum += int(item)**3
    if i == sum:
        print(i)
    sum = 0

三、break

for _ in range(3):
    pwd=input('请输入密码')
    if pwd == '54188':
        print('密码正确！')
        break
    else:
        print('密码不正确！')

---

a = 0
while a < 3:
    pwd = input('请输入密码')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码错误')
        a += 1

四、continue

for item in range(1, 51):
    if item % 5 != 0:
        continue
    print(item)

五、else

for item in range(3):
    pwd = input('请输入密码')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码错误')
else:
    print('你他娘的笨b')

三、循环嵌套 一、九九乘法表

for item in range(1, 10):
    for i in range(1, item+1):
            print(str(item)+'*'+str(i)+'='+str(item*i), end='t')
    print()

二、二重循环中break，continue

for i in range(5):
    for j in range(1, 11):
        if j % 2 == 0:
            break
        print(j)

四、列表 一、列表的创建

列表中元素按顺序有序排列，索引映射唯一元素，列表可以存储重复数据，可以存储不同数据类型，动态分配内存空间

list1 = [1, 2, 3, 4, 5, 6]#使用方括号
list2=list(['2','3','4'])#使用list函数 print(list1[1])#根据索引取值 print(type(list1))

二、列表 *** 作的方法

根据元素获取index(只返回第一个,若没有返回xxx not in list)：

print(list1.index(2,1,3))#后面两个参数表示在列表指定范围内查找

根据索引获取元素，索引长度为元素个数减一，第一个元素索引为0，反向索引最后一个为-1

print(list1[1]) 

print(list1[-2])

获取多个元素，切片 *** 作：

print(list1[1:5:2]) #参数为start，end，step用冒号分隔，默认步长为一

print(list1[-2:-5:-1]) #步长为负数时，start默认-1

in和not in判断某元素在列表中是否存在

列表添加元素：

list1.append('22')#在元素末尾添加一个元素

list1.extend(list2)#list2的每一项添加到list1

list1.insert(1, 90)#在指定索引位置添加元素

list1[1:]=list2#切片将切掉部分用list2替换

列表删除 *** 作：

list1.remove(4)#删除值为4的元素
list1.pop()  # 根据索引移除元素默认移除最后
new_list = list1[1:4]  # 删除元素产生新的对象
list[1:4]=[]#不生成新的对象
list1.clear()#删除列表

列表元素的删除 *** 作：

list1[4] = 3  # 修改一个值
list1[2:4] = [6, 5]  # 切片赋值

列表元素的排序 *** 作：

list1.sort()  # 对元素按照大小排序
list1.sort(reverse=1)  # 降序排序
new_list = sorted(list1) #生成新的对象

列表生成式：

list2 = [i*2 for i in range(10)]#列表里面存的是0，2，4...18

五、字典

字典用{key:value,..... }定义，以键值对存储数据，是可变的无序序列 原理与字典查相似，根据key查找value的值，key不能重复，用空间换时间，浪费较多内存空间

一、创建，获取数据，删除，修改

sex = {'张三': '男', '张三': '男', '李四': '女'}
sex2 = dict(name='mike', age='300', sex='人妖')

print(sex['李四'])#根据键查找
print(sex.get('张三', 90))#后面数字是键不存在时的默认值

del sex['张三']#删除
sex.clear()#清空字典

sex['gyq'] = '男'#新增
sex['gyq'] = '女'#修改

二、字典视图

keys = sex.keys()
print(keys)
values = sex.values()
print(values)
items = sex.items()
print(items)#返回的是个元组

三、字典生成式

names = ['张三', '三', '李四']
sexs = ['男', '男', '女']
d = {name: sex for name, sex in zip(names, sexs)}
print(d)

六、元组

可变序列：列表，字典  不可变序列：元组，字符串

为什么元组要设计成不可变序列：避免用户 *** 作对内容造成破坏

元组存储的是都对象的引用，如果元组中对象本身为不可变对象，则不能在引用其他对象

如果元组中对象为可变对象如列表，则可变对象的引用不可以改变，但数据可以改变

例子：

t = (2, '3', 3.2, [2, 3])
print(t[1], type(t[1]), id(t[1]))
print(t[3], type(t[3]), id(t[3]))
# t[1] = 100  # 报错不能修改
t[3].append(100)
print(t[3],id(t[3]))

一、创建

t = (2, '3', 3.2)
t = 2, 3, 44, 'saddsa'  # 括号可以省略
t = (1,)  # 当元组只有一个元素是需要有小括号逗号0
t = tuple(('a', 1, 33, 22.2))

二、元组遍历

for item in t:
    print(item)

明天再战！