day02 python基础

工程实训day02

今天继续了解python基础语法：

一、常用数据类型及内置方法

1.列表类型：

定义：在[]内，可以存放多个任意类型的值，并以逗号隔开。
一般用于存放学生的爱好，课堂的周期等等
需要优先掌握的相关操作：

student = ['项羽', '刘邦', '曹操']
print(student[1])  #输出：刘邦
info = ["刘备", 100, 'hope', ['魑魅1','魍魉2']]
# 1.按索引取值（正向或反向），只能取值
print(info[-1][0])
print(info[3])
print(info[3][1])
# 2.切片（顾头不顾尾，步长）
print(info[0:4:2])
# 3.长度
print(len(info))
# 4.成员运算
print(100 in info)
print('hope' not in info)
# 5.追加
student.append(12)
print(student)
# 6.删除
del student[2]
print(student)

除此之外需掌握的相关函数用法：

#获取列表中某个值的索引
print(info.index(100))
#获取列表中某个值的数量
print(info.count(100))
#取值，默认列表中最后一个值，类似删除
info.pop()
print(info)
#若pop()括号中写了索引，则取该索引对应的值
sex = info.pop(1)
print(sex)
print(info)
#移除，把列表中某个值的第一个值移除
stu = ["刘备", 100, 'hope', ['魑魅1','魍魉2'], 100]
val = stu.remove(100)
print(val)
print(stu)
#插入值(目的存储索引，存储值)
stu.insert(2, '唱跳rap')
print(stu)
#extend合并列表
stu.extend(student)
print(stu)
#循环
for stud in stu:
    print(stud)

2.元组类型：

定义：在()内可以存放多个任意类型的值，并以逗号隔开
注意：元组与列表不一样的是，只有在定义时初l始化，不能对其进行修改
优点：内存占用资源比列表小
相较列表除了修改其存放值的操作外，其他元组类型拥有同样操作。

tuplel = (1, 2, 3, '五', '六')
print(tuplel)
for line in tuplel:
    # print(line)
    # print默认end参数是\n
    print(line, end='_')  # 输出：1_2_3_五_六_

3.字典类型

作用：在{}内，以逗号隔开可存放多个值，以key-value存取，取值速度快
定义：key必须是不可变类型，value可以是任意类型
需要优先掌握的相关函数操作：

dict1 = dict({'age': 22, 'name': 'wang', 'level': 9})
print(dict1)
print(type(dict1))
# 取值，字典名 + []，括号内对应key
print(dict1['age'])

# 1.按key存取值，可存可取
dict1['age'] = 21
print(dict1)
# 2.长度
# 3.成员运算in和not in，只判断字典中的key
# 4.删除
del dict1['level']
print(dict1)
# 5.键keys()，值values()，键值对items()
# 得到字典中所有key
print(dict1.keys())
# 得到字典中所有值values
print(dict1.values())
# 得到字典中所有items
print(dict1.items())
# 6.循环
# 循环遍历字典中所有的key
for key in dict1:
    print(key)
    print(dict1[key])
# []取值
# print(dict1['sex']) # KeyError: 'sex'
# get取值
print(dict1.get('sex'))  # None
# 若找不到，则为其设置一默认值
print(dict1.get('sex', 'male'))

 

不可变类型：变量值修改后，其内存地址一定不一样
    数字类型int（float...）、字符串类型str、元组类型tuple
可变类型：列表类型list、字典类型dict

 

二 、流程控制

1.if 判断:

语法:
　　if 判断条件:
　　若条件成立，则执行此处代码
　　逻辑代码

　　elif 判断条件:
　　若条件成立，则执行此处代码
　　逻辑代码

　　else:
　　若以上判断都不成立，则执行此处代码
　　逻辑代码

简单例子：

# 判断两数大小
x = 10
y = 20
z = 30

if x > y:
    print(x)

elif z > y:
    print(z)

else:
    print(y)
# 最终输出30

1.循环

语法：
　　while 条件判断：
　　　　　　成立执行此处
　　　　　　逻辑代码
break 表示跳出本层循环
continue 表示结束本次循环，进入下次循环
其语句和C及其他语言类似，通俗易懂，方便观察有示例：

num = 0
while num < 3:
    name = input('请输入猜字符：').strip()
    if name == 'wang':
        print('success!')
        break
    print('请重新输入！')
    num += 1

 三、文件处理

open()
    写wt、读rt、追加at
    注意：必须指定字符编码，以什么方式写，就得以什么方式打开
执行python文件的过程：
    1.先启动python解释器，加载到内存中。
    2.把写好的python文件加载到解释器中。
    3.检测python语法，执行代码。
    SyntaxError：语法错误
示例用法：

# 参数一：文件的绝对路路径
# 参数二：操作文件的模式
# 参数三：encoding指定的字符编码
f = open('file.txt', mode='wt', encoding='utf-8')
f.write('wang')
f.close()  # 关闭操作系统文件的资源

# 追加文本文件
f = open('file.txt', mode='at', encoding='utf-8')
f.write('\nYiming')
f.close()
'''
文件处理之上下文管理
with open () as f “句柄”
with可以管理open打开的文件，会在with执行完毕后自动调用close()
'''
with open("file.txt", "r", encoding="utf_8") as f:
    # res = f.read()
    print(f.read())

# 通过with来管理打开的两个文件句柄
with open("D:\\壁纸\\1957-106.jpg", "rb") as f_r, open("test.jpg", "wb") as f_w:
    # 通过f_r句柄把图片的二进制流读取出来
    res = f_r.read()
    # 通过f_w句柄把图片的二进制流写入test.jpg文件中
    f_w.write(res)

四、函数

定义：指的其实一把工具。
    使用函数的好处：
    1.解决代码冗余问题。
    2.使代码的结构更清晰。
    3.易管理。
    函数的使用必须遵循：先定义，后调用。
    
函数定义语法：
    def  函数名（参数1，参数2...）：
        注释：声明函数
        逻辑代码
        return返回值
    def: defind 定义。
    函数名：必须看其名知其意。
    ()：接收外部传入的参数。
    注释：用来声明函数的作用。
    return：返回给调用者的值。
    
定义函数的三种形式：
    1.无参函数
    不需要接收外部传入的参数。
    2.有参函数
    需要接收外部传入的参数。
    3.空函数
    pass

1.无参函数

def login():
    user = input("请输入用户名：").strip()
    pwd = input("请输入密码：").strip()
    if user == "wang" and pwd == 123:
        print("success!")
        return
    print("Error")
    # else: print("Error")


login()
print(login)  # 函数的内存地址

2.有参函数

# 若函数在定义时需要接收参数，调用者必须为其穿传参
def login(username, password):
    user = input("请输入用户名：").strip()
    pwd = input("请输入密码：").strip()
    if user == username and pwd == password:
        print("success!")
    else:
        print("Error")


login('wang', '123')

3.空函数

def login():
    pass  # 什么都不做

默认参数：在定义阶段，为参数设置默认值

def func(x=100, y=10):
    print(x, y)
    return


func(1, 2)  # 传参，使用传入的参数
func()  # 不传参，则使用默认参数
func(x=1000)


def foo(x, y):
    print(x, y)
    return


foo(y=13, x=14)  # 使用此法不能少传，不能多传

4.函数嵌套

函数的嵌套定义：在函数内部定义函数。
函数对象：函数的名称空间

函数的嵌套定义：在函数内部定义函数。

def func1():
    print('from func1...')

    def func2():
        print('from func2...')

函数对象：函数的内存地址称之为函数对象。
    函数的名称空间：
    内置：
    python解析器自带的都称之为“内置名称空间"。
    全局：
    所有顶着头写的变量、函数...都称之为“全局名称空间"。
    局部：
    在函数内部定义的，都称之为“局部名称空间"。
    名称空间加载顺序：
         内置-—->全局-—->局部
    名称空间查找顺序：
         局部-—->全局-—->内置

# 函数对象
print(func1)


def f1():
    pass


def f2():
    pass


dic1 = {'1': f1, '2': f2}

choice = input('请选择功能编号: ')
if choice == '1':
    print(dic1[choice])
    dic1[choice]()

elif choice == '2':
    print(dic1[choice])
    dic1[choice]()

总的来说还是基础，语言之间存在太多共同点，了解此，便可举一反三。