首页 > 文章 > 2019_6_25

2019_6_25


一、列表:

  定义:

    在[]内,可以存放多个任意类型的值,并以逗号隔开。一般用于存放学生的爱好,课堂的周期等等。。。

定义一个学生列表,可存放多个学生
student = [钱垚, 李小龙, 张一, 李二]
print(student[1])  # 李小龙

student_info = [杨波, 84, male, [泡8, 喝9]]
取杨波同学的所有爱好
print(student_info[3])
取杨波同学的第二个爱好
print(student_info[3][1])
优先掌握的操作:

1、按索引存取值(正向存取+反向存取):即可存也可取
print(student_info[-2])  # 杨波
2、切片(顾头不顾尾,步长)
print(student_info[0:4:2])  # [‘杨波‘,‘male‘]
3、长度
print(len(student_info))  # 4
4、成员运算in和not in
print(杨波 in student_info)  # True
print(杨波 not in student_info)  # False
5、追加
在student_info列表末尾追加一个值
student_info.append(安徽,合肥学院)
print(student_info)
6、删除
删除列表中索引为2的值
del student_info[2]
print(student_info)
7、循环
for student in student_info:
    print(student, end= )
需要掌握的:
student_info = [杨波, 95, female, [尬舞, 喊麦], 95]
1、index获取列表中某个值的索引
print(student_info.index(95))  # 1
2、count获取列表中某个值大的数量
print(student_info.count(95))  # 2
3、取值,默认取列表中最后一个值,类似删除,若pop()括号中写了索引,则取索引对应的值
student_info.pop()
print(student_info)
取出列表中索引为2的值,并赋值给sex变量名
sex = student_info.pop(2)
print(sex)
print(student_info)
4.移除,把列表中的某个值的第一个值移除
student_info = [尹浩卿, 95, female, [尬舞, 喊麦], 95

student_info.remove(95)
print(student_info)  # [‘尹浩卿‘, ‘female‘, [‘尬舞‘, ‘喊麦‘], 95]
name = student_info.remove(尹浩卿)
print(name)  # None
print(student_info)  # [‘female‘, [‘尬舞‘, ‘喊麦‘], 95]
插入值
student_info = [尹浩卿, 95, female, [尬舞, 喊麦], 95]
# # 在student_info中,索引为3的位置插入“合肥学院”
# student_info.insert(3, ‘合肥学院‘)
# print(student_info)
6.extend 合并列表
student_info1 = [尹浩卿, 95, female, [尬舞1, 喊麦2], 95]
student_info2 = [娄逸夫, 94, female, [尬舞1, 喊麦2]]
# 把student_info2所有的值插入student_info1内
student_info1.extend(student_info2)
print(student_info1)
二、元组类型:
    定义:
在()内,可以存放多个任意类型的值,并以逗号隔开。
注意:
元组与列表不一样的是,只能在定义时初始化值,不能对其进行修改。
优点:
在内存中占用的资源比列表要小。
定义:
#  tuple((1, 2, 3, ‘五‘, ‘六‘))
tuple1 = (1, 2, 3, , )
print(tuple1)  # (1, 2, 3, ‘五‘, ‘六‘)
优先掌握的操作:
1、按索引取值(正向取+反向取):只能取
print(tuple1[2])  # 3
2、切片(顾头不顾尾,步长)
从0开始切片到5-1, 步长为3
print(tuple1[0:5:3])  # (1, ‘五‘)

3、长度
print(len(tuple1))  # 5
4、成员运算in和not in
print(1 in tuple1)  # True
print(1 not in tuple1)  # False
5、循环
for line in tuple1:
    # print(line)
    # print默认end参数是\n
    print(line, end=_)

三、不可变类型与可变类型:

不可变类型:    
变量的值修改后,内存地址一定不一样。
数字类型
int
float

字符串类型
str

元组类型
tuple

可变类型:
列表类型
list

字典类型
dict


不可变类型
int
 number = 100
 print(id(number))  # 1434810944
 number = 111
 print(id(number))  # 1434811296

 float
 sal = 1.0
 print(id(sal))  # 2771339842064
 sal = 2.0
 print(id(sal))  # 2771339841896

 str1 = hello python!
 print(id(str1))  # 1975751484528
 str2 = str1.replace(hello, like)
 print(id(str2))  # 1975751484400
# 可变类型:
# 列表
list1 = [1, 2, 3]

list2 = list1
list1.append(4)

 list1与list2指向的是同一份内存地址
print(id(list1))
print(id(list2))
print(list1)
print(list2)

四、字典类型

字典类型:
作用:
在{}内,以逗号隔开可存放多个值,
以key-value存取,取值速度快。

定义:
key必须是不可变类型,value可以是任意类型

dict1 = dict({age: 18, name: tank})
 dict1 = {age: 18, name: tank}
 print(dict1)  # {‘age‘: 18, ‘name‘: ‘tank‘}
 print(type(dict1))  # <class ‘dict‘>

取值,字典名 + [],括号内写值对应的key
print(dict1[age])
 优先掌握的操作:
1、按key存取值:可存可取
存一个 level: 9的值到dict1字典中
 dict1[level] = 9
 print(dict1)  # {‘age‘: 18, ‘name‘: ‘tank‘, ‘level‘: 9}
 print(dict1[name])  # tank
 2、长度len

3、成员运算in和not in 只判断字典中的key
 print(name in dict1)  # True
 print(tank in dict1)  # False
 print(tank not in dict1)  # True
 4、删除
 del dict1[level]
 print(dict1)  # {‘age‘: 18, ‘name‘: ‘tank‘}
 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])

 get
dict1 = {age: 18, name: tank}
 print(dict1.get(age))
 []取值
 print(dict1[sex])  # KeyError: ‘sex‘
 get取值
print(dict1.get(sex))  # None
 若找不到sex,为其设置一个默认值
print(dict1.get(sex, male))

五、流程控制

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

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

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

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

# 缩进快捷键,tab往右移动四个空格,shift + tab 往左移动四个空格
if x > y:
    print(x)

elif z > y:
    print(z)

else:
    print(y)
‘‘‘
while循环
语法:
while 条件判断:
# 成立执行此处
逻辑代码

break # 跳出本层循环
continue # 结束本次循环,进入下一次循环
‘‘‘

str1 = ‘tank‘

# while循环
while True:
    name = input(请输入猜测的字符: ).strip()
    if name == tank:
        print(tank success!)
        break

    print(请重新输入! )
# 限制循环次数
str1 = ‘tank‘
初始值
num = 0 # 0 1 2 3

# while循环
while num < 3:
    name = input(请输入猜测的字符: ).strip()
    if name == tank:
        print(tank success!)
        break

    print(请重新输入!)
    num += 1

六、文件处理

open()

写文件
wt: 写文本

读文件
rt: 读文本

追加写文件
at: 追加文本

注意: 必须指定字符编码,以什么方式写
就得以什么方式打开。 如: utf-8

执行python文件的过程:
1.先启动python解释器,加载到内存中。
2.把写好的python文件加载到解释器中。
3.检测python语法,执行代码。
SyntaxError: 语法错误!

打开文件会产生两种资源:
1.python程序
2.操作系统打开文件



文件处理之上下文管理:

1、with可以管理open打开的文件,
会在with执行完毕后自动调用close()关闭文件

with open()

2、with可以管理多个文件

‘‘‘
‘‘‘

‘‘‘
文件处理:
open()

写文件
wt: 写文本

读文件
rt: 读文本

追加写文件
at: 追加文本

注意: 必须指定字符编码,以什么方式写
就得以什么方式打开。 如: utf-8

执行python文件的过程:
1.先启动python解释器,加载到内存中。
2.把写好的python文件加载到解释器中。
3.检测python语法,执行代码。
SyntaxError: 语法错误!

打开文件会产生两种资源:
1.python程序
2.操作系统打开文件
‘‘‘

写文本文件
参数一: 文件的绝对路径
参数二: mode 操作文件的模式
参数三: encoding 指定的字符编码
f = open(file.txt, mode=wt, encoding=utf-8)
f.write(tank)
f.close()  # 关闭操作系统文件资源
# 读文本文件  r == rt
f = open(file.txt, r, encoding=utf-8)
print(f.read())
f.close()
# 追加写文本文件

a = open(file.txt, a, encoding=utf-8)
a.write(\n 合肥学院)
a.close()

七、函数基础

什么是函数?
函数指的其实一把工具。

使用函数的好处:
1.解决代码冗余问题。
2.使代码的结构更清晰。
3.易管理。

函数的使用必须遵循: 先定义,后调用。

函数定义语法:

def 函数名(参数1, 参数2...):
‘‘‘注释: 声明函数‘‘‘
逻辑代码

return 返回值

def: defind 定义。
函数名: 必须看其名知其意。
(): 接收外部传入的参数。
注释: 用来声明函数的作用。
return: 返回给调用者的值。

‘‘‘‘‘‘
‘‘‘
def 函数名(参数1, 参数2...):
"""注释: 声明函数"""
逻辑代码

return 返回值

def: defind 定义。
函数名: 必须看其名知其意。
(): 接收外部传入的参数。
注释: 用来声明函数的作用。
return: 返回给调用者的值。
‘‘‘

‘‘‘
定义函数的三种形式:
1.无参函数
不需要接收外部传入的参数。

2.有参函数
需要接收外部传入的参数。

3.空函数

pass


函数调用:
函数名 + () 调用

‘‘‘

# 1.无参函数
def login():
    user = input(请输入用户名).strip()
    pwd = input(请输入密码).strip()

    if user == tank and pwd == 123:
        print(login successful!)

    else:
        print(login error!)
# 函数的内存地址
print(login)
# 函数调用
login()
2.有参函数
username,password 用来接收外部传入的值
def login(username, password):
    user = input(请输入用户名).strip()
    pwd = input(请输入密码).strip()

    if user == username and pwd == password:
        print(login successful!)

    else:
        print(login error!)
# 函数调用
# 若函数在定义时需要接收参数,调用者必须为其穿传参
login(tank, 123)
# 3.空函数
‘‘‘
ATM:
1.登录
2.注册
3.提现
4.取款
5.转账
6.还款
# 登录功能
def login():
    # 代表什么都不做
    pass


# 注册功能
def register():
    # 代表什么都不做
    pass


# 还款功能
def repay():
    pass
函数的参数:
在定义阶段: x, y称之为形参。
def func(x, y):  # x, y
    print(x, y)
# 在调用阶段: 10, 100 称之为实参。
func(10, 100)


‘‘‘
位置参数:
位置形参
位置实参
必须按照位置一一传参。
‘‘‘
# 在定义阶段: 位置形参
def func(x, y):  # x, y
    print(x, y)
#
# # 在调用阶段: 10, 100 称位置实参。
func(10, 100)  # 10 100
‘‘‘
关键字参数:
关键字实参
按照关键字传参。
‘‘‘
# 位置形参x, y
def func(x, y):
    print(x, y)

# 在调用阶段: x=10, y=100称之为关键字参数。
func(y=111, x=10)  # 10 111

不能少传
func(y=111)  # 报错TypeError


不能多传
func(y=111, x=222, z=333)  # 报错TypeError
‘‘‘
默认参数:
在定义阶段,为参数设置默认值
‘‘‘

def foo(x=10, y=20):
    print(x, y)
# 不传参,则使用默认参数
foo()
# 传参,使用传入的参数
foo(200, 300)
‘‘‘‘‘‘
‘‘‘
函数的嵌套定义:
在函数内部定义函数。

函数对象:
函数的内存地址称之为函数对象。

函数的名称空间:
内置:
python解析器自带的都称之为"内置名称空间"。

全局:
所有顶着头写的变量、函数...都称之为"全名称空间"。

局部:
在函数内部定义的,都称之为"局部名称空间"。

名称空间加载顺序:
内置 ---> 全局 ---> 局部

名称空间查找顺序:
局部 ---> 全局 ---> 内置
‘‘‘


# 函数的嵌套定义
def func1():
    print(from func1...)

    def func2():
        print(from func2...)
# 函数对象
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]()

x = 10
# 名称空间
# 函数的嵌套定义
def func1():
    # x = 20

    print(from func1...)

    print(x)  # 报错

    x = 30

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


func1()

 

时间:2019-06-26 00:24:20阅读(39)
联系我们 - 留言反馈
© 2017 版权所有 鲁ICP备17052893号