python入门笔记之熟练编程

python入门笔记之熟练编程

昨日内容回顾

1. whie+else

while 满足的条件：
	循环体代码
else:
	满足的条件正常循环至不满足时执行
	(即不被break打断)

2. for循环的使用

语法较while循环简单，但是功能不如while强大，只适合取值
for 变量名 in 数据集合：
	循环体代码

3. range关键字

range(最大数字)
range(起始数，最大数字)
range(起始数，最大数字，间隔数)
默认从0开始，顾头不顾尾

4. for的嵌套

for i in range(5):
    for j in range(10):
        print(i,j)
大循环每循环一次，小循环循环10次

5. 字符串内置方法

# 1.索引取值
变量名（[索引值]）
# 2.切片操作
变量名（索引值[起始数:结尾数）
# 3.步长(间隔数、方向)
变量名（索引值[起始数:结尾:间隔数]）
# 4.统计字符的个数
	len(变量名)
# 5.移除字符串首尾指定的字符
	strip()  # 括号内指定字符 不知道默认移除空格
# 6.按照指定的字符切割字符串
	split()  # 默认全部切割 也可以指定切割的个数
    	max_split = 1  # 从左往右
    rsplit()  # 从右往左
    	max_split = 1  # 从右往左

今日学习内容

字符串的内置方法

移除字符串首尾的指定字符

可以选择方向

# s1 = '$$$eason$$$'
# print(s1.strip('$'))  # eason
# print(s1.lstrip('$'))  # eason$$$       left    左边
# print(s1.rstrip('$'))  # $$$eason       right   右边

大小写转换操作

# a = 'eAsOn'
# print(a.lower())  # 将所有的英文字母变为小写 'eason'
# print(a.upper())  # 将所有的英文字母变为大写 'EASON'
# print(s2.islower())  # 判断字符串中所有的英文字母是否是纯小写  True或false
# print(s2.isupper())  # 判断字符串中所有的英文字母是否是纯大写  True或false

判断字符串开头或结尾是否是指定字符

print(变量名.startswith('单个字符或一串'))

格式化输出

方式一:占位符:%s %d
方式二：format（四种用法）
1.和占位符相同，使用{}占位
2.根据索引取值  可以反复使用
print('my name is {0} {0} {0} my age is {1} {1}'.format('数据', '数据'))
3.直接取变量名
print('my name is {变量名}'.format(变量名='值'))
4.取已经出现过的变量名使用
name = 'eason
age = 21
print(f'my name is {name} my age is {age} ')
my name is easonge is 21.

拼接字符串

1.直接使用加号+
	字符串较大时，工作效率较低
2. join
	a1 = '漆黑'
	a2 = '意志'
a3 = ('|'.join(['s1','s2']))
print('a3')
漆黑|意志
join的元素必须都是字符串 否则报错

替换字符串中字符

replace
print(字符串.replace('旧','新'))

指定个数
print(字符串.replace('旧','新',个数))
只可从左往右

判断字符串中是否是纯数字

isdigit
布尔值作为检测结果
print(字符串.isdigit)

查找指定字符对应的索引值

find
a = 'eason jojo faiz eva'
print(s1.find('想要的字符'))  # 从左往右查找 查找一个就结束

print(s1.find('想要的字符', 起始数, 最大数)) 
-1 代表没有
index 用法相同与find ，但是找不到直接报错
不推荐使用

文本位置改变

center
a = '数据'
print(a.ceter(填充位数，'填充符号'))
ceter  文本居中
ljust  文本居左
rjust  文本具右
zfill  默认使用0作填充

特殊符号

\t 留下四个空格
\n 换行
\a 留下特殊符号
'''如果想取消它们的特殊含义 可以在字符串的前面加一个字母r'''

captalize,swapcase,title

.captalize：首字母大写
.swapcase：大小写翻转
.title：每个单词的首字母大写

列表内置方法

1.类型转换
	print(list(11)) 
    print(list(11.11)) 
    数字类型不可转换为列表
    print(list('eason'))  # ['e', 'a', 's', 'o', 'n']
    转换字符串，单个字符依次转换
    print(list({'name': 'eason', 'pwd': 1874}))  # ['name', 'pwd']
    转换字典只可转换K值
    print(list((11,22,33,44,55)))  # [11, 22, 33, 44, 55]
    转换集合，依次转换
    print(list({1, 2, 3, 4, 5}))  # [1, 2, 3, 4, 5]
    转换元组，依次转换
    print(list(True))
    布尔值不可转换

索引取值

print(列表[0])  # 检索第一位
print(列表[-1])  # 检索最后一位	 

切片操作

print(列表[起始值，结束值])
可以使用负数检索 
-1为最后一位，依次类推
print(列表[起始值，结束值，间隔值])

统计列表中元素的个数

print(len(列表)) 

成员运算

结果为布尔值
print('需要检测的单个元素' in 列表)
只可检测最小单位为单个元素，单个字符无法检测.

列表添加元素的方式

1.列表尾部添加
列表.append('需要加入的元素')
2.指定位置添加单个元素
列表.insert(需要插入的位置的检索值'需要加入的元素')
3.合并列表
列表.extend([列表])
extend = for循环 + append

删除元素

1.检索值删除
del 列表[0]
2.指定删除
列表 = [元素1，元素2，元素3]
print(列表.remove(元素1))  无数值
print(列表)
3.延迟删除
列表 = [元素1，元素2，元素3]
print(列表.pop(检索值或元素1))  有数值
print(列表)

修改列表元素

print(id(name_list[2]))
name_list[2] = 'jojo'
print(id(name_list[2]))
print(name_list)

修改列表元素时，列表的变量名地址不更改
被修改的元素地址发生改变.

排序

a = [44, 77, 99, 11, 22, 33, 88, 66]
ss.sort()  
# 默认是升序

print(a)  
[11, 22, 33, 44, 66, 77, 88, 99]
ss.sort(reverse=True)  
# 可以修改尾降序

print(a)  
[99, 88, 77, 66, 44, 33, 22, 11]

翻转

a = [列表]
a.reverse()  # 前后颠倒
print(a)

比较运算

a = [11, 22, 33]
b = [1, 2, 3, 4, 5, 6, 7, 8]
print(a > b)  # True

列表在做比较的时候 ,

比的是对应索引位置上的元素.

统计列表中某个元素出现次数

print(列表.count(列表))

清空列表

列表.clear()

可变类型与不可变类型

可变类型与不可变类型
可变类型     列表
值改变 内存地址不变 修改的是本身


不可变类型   字符串
值改变 内存地址肯定遍 修改过程产生了新的值

查看变量的地址

print(id(变量名))

队列与堆栈

队列：先进先出
堆栈：后进先出

# 使用列表模拟出队列与堆栈的特征
# 队列
new_list = []
# 先进
# 先进
new_list.append(1)
new_list.append(2)
new_list.append(3)
# 先出
for i in new_list:
    print(new_list.pop(0))
    print(new_list.pop(0))
    print(new_list.pop(0))
依次取出检索值为0的元素

# 使用列表模拟出队列与堆栈的特征
	# 队列
new_list = []
# 先进
new_list.append(1)
new_list.append(2)
new_list.append(3)
# 先出
for i in new_list:
    print(new_list.pop(-1))
    print(new_list.pop(-1))
    print(new_list.pop(-1))
依次取出检索值为-1的元素

作业

将登录功能编写成多用户模式，

利用列表编写一个用户注册、登录程序

account_lise = ['eason|1874', 'jojo|24', 'faiz|555']  # 创建一个数据库
a = 3  # 放置一个计数器
flag = True  # 设置一个flag值
while a > 0 and flag:  # 创造一个循环，利用计数器控制循环条件
    username = input('请输入您的账户>>>:').strip()  # 获取账户输入,忽略前后空格
    password = input('请输入您的密码>>>:').strip()  # 获取密码输入,忽略前后空格
    Account = ('|'.join([username, password]))  # 将用户输入数据用管道符相链接
    account = Account.lower()  # 将用户输入全部转换为小写
    if len(username) == 0:  # 检测字符串长度，为0时运行
        print('用户名不能为空')  # 打印
        continue  # 结束本次循环
    if len(password) == 0:  # 检测字符串长度，为0时运行
        print('密码不能为空')  # 打印
        continue  # 结束本次循环
    if (account in account_lise):  # 利用成员运算搜寻用户输入是否在数据库中
        print('恭喜您，登录成功')  # 打印
        k = True  # 设置第二个flow值
        while k:  # 如果K等于True时进行循环
            print('执行命令请输入，退出请输入GG，更换用户请输入CC')  # 打印
            i = input('请输入您的命令>>>:').lower().strip()  # 获取用户输入赋值给i，并转换小写，去除首位空格
            if i == 'gg':  # 如果i等于GG继续,准备终止所有循环
                print('正在退出，感谢使用')  # 打印
                flag = False  # 更改flow值，停止最大循环
                k = False  # 更改Flag，终止中层循环
                break  # 跳出本层小循环
            elif i == 'cc':  # 如果i等于cc，回到登录界面
                break  # 跳出中层循环，回到大循环
            else:  # 不满足上面条件时运行
                print('正在执行您的指令···')  # 打印
                print(i)  # 打印出用户输入
                flag = False  #
    else:
        print('输入错误，请您重试')  # 对比失败，则打印
        a -= 1  # 每次循环，计数器减少1
        if a == 0:  # 三次错误后，当计数器归零时
            j = True  # 设置flow值
            while j:  # 小循环开始
                yes_no = input('重新输入/注册/退出，y/s/n').lower().strip()  # 获取用户输入，转换小写，去除首位空格
                if yes_no == 'y':  # 用户输入为y
                    print('请您重新输入')  # 打印
                    a = 3  # 重置大循环计数器
                    break  # 跳出当前小循环
                elif yes_no == 'n':  # 用户输入为n
                    print('正在退出····')  # 打印
                    break  # 跳出大循环，退出程序
                elif yes_no == 's':  # 用户输入为s
                    v = True  # 设置flow值
                    while v:  # 根据v值循环
                        username2 = input('请输入您的新账户').lower().strip()  # 获取新用户名输入
                        password2 = input('请输入您的新密码').lower().strip()  # 获取新用户密码输入
                        password3 = input('请重新输入您的密码').lower().strip()  # 获取新用户密码重复输入
                        if password2 == password3:  # 密码校验
                            account2 = ('|'.join([username2, password2]))  # 将用户输入转换为管道符拼接并赋值
                            account_lise.append(account2)  # 将赋值保存到数据库
                            print('注册成功，请登录')  # 打印
                            j = False  # 结束j层循环
                            a = 3  # 重置计数器
                            v = False  # 结束v层小循环，返回登录页面
                        else:  # 密码校验失败
                            print('密码错误，请您重新注册')  # 打印，并回到注册小循环
                else:  # 用户输入不为y s n 时
                    print('请您正确输入') # 打印并返回j层小循环

# 1.满足三次错误，询问用户是否继续
# 2.满足用户不分大小写，前后留空格输入习惯
# 3.空输入报错，重新输入并且不计数
# 4.登录后满足执行命令功能
# 5.登录后满足切换用户功能
# 6.错误三次后满足注册功能（这样其实有点反逻辑，后面可以修改成登录界面注册）
# 7.注册密码需要校验
# 8.注册完成后可正常返回登录页面其他功能

今日总结

越来越能感受到学习的辛苦；

但是我觉得编程还是很有意思的，可以将自己的想法，放大并实现

锻炼逻辑思维，在未来生活也会让判断力更加进一步，

总而言之，学习能力决定个人的上限.