Python学习记录（让你从白中白到简单入门）-CSDN博客

本文链接：https://blog.csdn.net/m0_64497563/article/details/123421769

显式类型转换

数据结构（序列结构）

1. 序列（序列是 Python 中最基本的数据结构）——中括号[]

提示：

2.元组(Python 的元组与列表类似，不同之处在于元组的元素不能修改)——小括号()，一般就直接用','隔开

提示：

3.字典（字典是另一种可变容器模型，且可存储任意类型对象）——大括号{}

提示：

4.集合（集合（set）是一个无序的不重复元素序列）——大括号{}

条件语句if – elif – else：

循环语句（此处使用for示例，while在上面已经说过了）

5.匿名函数：Python 使用 lambda 来创建匿名函数

6.return语句的使用：语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None

包：管理 Python 模块命名空间的形式（类似与模块写函数）

显式类型转换

1.int() 强制转换为整型

2.float()强制转换为浮点型

3.str() 强制转换为字符串类型

示例：

num_str='123'#这是一个字符型的变量
num_str = int(num_str)    # 强制转换为整型
print("类型转换后，num_str 数据类型为:",type(num_str))#使用type()可以查看变量类型

数据结构（序列结构）

1. 序列（序列是 Python 中最基本的数据结构）——中括号[]

创建示例:


list1 = ['Google', 'Runoob', 1997, 2000]#可以存在不同的数据结构
list2 = [1, 2, 3, 4, 5 ]#基本格式就是中括号括起来，逗号分开
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

序列中的索引：

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )#第一个值
print( list[1] )#第二给值

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )#倒数第一个数
print( list[-2] )#倒数第二个数

可以实现多个数的访问(正反索引)

示例：

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]#正向示例
print(nums[0:4])#基本的格式就是括起来 第一个值(包括):停止的值(不包含)

list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]#反向示例
print (list[1:-2])#从第一个数到倒数第二个数（不包括倒数第二个数）

通过索引列表可以进行截取、组合等操作

更新列表：

list = ['Google', 'Runoob', 1997, 2000]
list[2] = 2001#直接赋值修改即可

增添值：

#list.append(value)
list1 = ['Google', 'Runoob', 'Taobao']#在列表末尾增加元素
list1.append('Baidu')#需要添加值的list.append(值)

删除值：

#del list[索引]
list = ['Google', 'Runoob', 1997, 2000]
del list[2]#直接使用del 需要删除的那个值的索引

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

#list.count(value)
aList = [123, 'Google', 'Runoob', 'Taobao', 123]
print ("123 元素个数 : ", aList.count(123))#统计其（123）个数
print ("Runoob 元素个数 : ", aList.count('Runoob'))#统计('Runoob')个数

在列表末尾一次性追加另一个序列中的多个值:

#list.extend(seq)
list1 = ['Google', 'Runoob', 'Taobao']
list2=list(range(5)) # 创建 0-4 的列表
language_tuple = ('Spanish', 'Portuguese')#这是一个元组
list1.extend(list2)  # 用列表扩展列表
list1.extend(language_tuple)#用元组扩展列表

从列表中找出某个值第一个匹配项的索引位置：

#list.index(value)
list1 = ['Google', 'Runoob', 'Taobao']
print (list1.index('Runoob'))#输出1

函数用于将指定对象插入列表的指定位置：

#list.insert(index, obj)
list1 = ['Google', 'Runoob', 'Taobao']
list1.insert(1, 'Baidu')#将字符'Baidu'嵌入到原索引1的位置

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值：

#list.pop([index=-1])
#pop()
#index里面默认最后一个(-1),可以通过直接修改索引

list1 = ['Google', 'Runoob', 'Taobao']
list1.pop()#默认移除最后一个
list1.pop(1)#移除第二个

移除列表中某个值的第一个匹配项:

#list.remove(obj)
list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.remove('Taobao')#指定移除字符'Taobao'

反向列表中元素:

#list.reverse()
list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.reverse()#实现反向

清除列表：

#list.clear()
list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.clear()#清楚整个列表的值，仍然可以输出这个列表，但是没值

复制列表：

#list.copy()
list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list2 = list1.copy()#将list1的值全部copy to list2

对原列表进行排序：

#list.sort( key=None, reverse=False)
#key=particular value(比较对象，默认为none)
#reverse=False/Ture
#False是默认的升序，Ture是降序
#key我不会
vowels = ['e', 'a', 'u', 'o', 'i']
vowels.sort(reverse=True)#降序输出

有关列表的其他Python包含的函数：

len(list)#求列表中元素的个数

max(list)#返回列表最大值

min(list)#返回列表最小值

list(seq)#将 元素列表转换为列表(list)    tips:元组和列表很像，就是里面的值不能像列表一样修改

提示：

列表可以拼接'+'；
也可以嵌套（即使用内列表当作外列表的值）
seq -- 元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾。
2.元组(Python 的元组与列表类似，不同之处在于元组的元素不能修改)——小括号()，一般就直接用','隔开

创建示例（Tuple）：

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"   #  不需要括号也可以

删除元组：

#del Tuple
tup = ('Google', 'Runoob', 1997, 2000)
del tup#删除整个Tuple

判断元组里的元素存在：

#a particular value in Tuple
3 in (1, 2, 3)

迭代：

for x in (1, 2, 3): 
    print (x, end=" ")

提示：

元组由若干逗号分隔的值组成
元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用（会被误认为整型，而不是元组）
元组可以使用下标索引来访问元组中的值（和list一样）
元组中的元素值是不允许修改的，但是可以合并(使用'+')
元组的复制 {('Hi!',) * 4}
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
len(Tuple)输出元素个数(与list相同)
min(tuple)，max(tuple)
3.字典（字典是另一种可变容器模型，且可存储任意类型对象）——大括号{}

基本格式:

d = {key1 : value1, key2 : value2, key3 : value3 }
#key必须是唯一的
#value可以相同

访问字典内部的值：

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print (tinydict['Name'])#大括号内写key
print (tinydict['Age'])

修改字典：

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "我很帅"  # 添加信息

删除字典元素：

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典

返回一个字典的浅复制：

#dict.copy()
#引用就是如果被引用的的发生改变，引用的地方也发生改变
#目录的解释，第一个叫一级，依次后退
#深度拷贝就是已经转移过来，和原来的无关了，不会随其改变而改变
#对于.copy潜复制，只有一级目录是深度拷贝
dict1 =  {'user':'runoob','num':[1,2,3]}
dict2 = dict1          # 浅拷贝: 引用对象
dict3 = dict1.copy()   # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，子对象是引用
dict1['user']='root'#修改一些数据以便测试
dict1['num'].remove(1)
print(dict1)#输出结果验证
print(dict2)
print(dict3)

创建一个新字典：

#newdict=dict.fromkeys(seq, value)
#seq是一个列表，用于给新字典命名的
#值可以是任何变量形式，列表也可以
#value,是对所以的键赋值初始化
#可以不赋值，那么默认0，如果赋值数小于键数，那么后面会赋值为最后一个值
seq = ('name', 'age', 'sex')#创建一个列表
newdict = dict.fromkeys(seq['liuaiwo',24,'man'])
print (str(newdict))

Python 字典 get() 函数返回指定键的值：

#dict.get(key, value) 
#用这样的一个方法去找dict中的某一个值比直接dict[key]好在于不会报错
#key是对应dict里的某一个键
#value是当找不到这个键的时候，输出的值
#dict可以嵌套，那么get也可以 比如tinydict.get('RUNOOB', {}).get('url')
#'RUNOOB'和'url'都是key

tinydict = {'Name': 'Runoob', 'Age': 27}
print ("Age : ", tinydict.get('Age'))#简单的用法，就是获取某一个键对应的值
print ("Sex : ", tinydict.get('Sex'))  #这个是实验如果不设置value 默认输出的就是none
print ('Salary: ', tinydict.get('Salary', 'hahaha'))#这个是设置value后

判断键是否存在于字典中:

#key in dict
#key not in dict
#同理的判断
#对于存在输出True，不存在输出False
thisdict = {'Name': 'Runoob', 'Age': 7}
if  'Age' in thisdict:     #书写规范是叫’:‘
    print("键 Age 存在")
else :
    print("键 Age 不存在")

#dict.setdefault(key, default=None)
# setdefault() 方法和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值
#后面的默认值可以认为设置
tinydict = {'Name': 'Runoob', 'Age': 7}
print ("Age 键的值为 : %s" %  tinydict.setdefault('Age', None))
print ("Sex 键的值为 : %s" %  tinydict.setdefault('Sex', 'man'))#默认值设为'man'
print ("新字典为：", tinydict)

以列表返回视图对象：

#dict.items()
#与c一样，需要一些格式，%s对应字符串，以%后面的替代%s
tinydict = {'Name': 'Runoob', 'Age': 7}
print ("Value : %s" %  tinydict.items())#视图返回一个字典对象

#dict.keys()
#这里返回的是键的可视图
dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
keys = dishes.keys()#将全部的键导出
values = dishes.values()#将全部的值导出
#可以用print去看看可视图
print('%s' % keys)
print('%s' % values)

把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里:

#dict.update(dict2)
tinydict = {'Name': 'Runoob', 'Age': 7}
tinydict2 = {'Sex': 'female' }
tinydict.update(tinydict2)
print ("更新字典 tinydict : ", tinydict)

删除字典给定键 key 所对应的值:

#pop(key[,default])
#
site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
pop_obj1=site.pop('name')#它的返回值对应的是key对应的value
pop_obj2=site.pop('sex','noexist')#它的返回值对应的是'noexist'
print(pop_obj1,pop_obj2)

#popitem()
#Python 字典 popitem() 方法随机返回并删除字典中的最后一对键和值
#如果字典已经为空，却调用了此方法，就报出KeyError异常
#返回一个键值对(key,value)形式，即最末尾的键值对
#这个是删除整个键值的method
site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
pop_obj=site.popitem()
print(pop_obj)  
print(site)

提示：

不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
str(dict)输出字典
len(dict)计算字典元素个数
dict.clear()清除元素
4.集合（集合（set）是一个无序的不重复元素序列）——大括号{}
基础创建：

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
set{1,2,3,4,5}

添加元素：

#set.add( x )
thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook")#add(x)，x是需要添加的元素
print(thisset)

#参数可以是列表，元组，字典等
#s.update( x )
#使用update更新集合
thisset = set(("Google", "Runoob", "Taobao"))#这里是使用set()去创建的一个集合
thisset.update({1,3})#当里面有多个的时候使用','隔开
print(thisset)

返回集合的差集：

#set.difference(set)
#返回存在与头set的，且不在尾set的值
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
z = x.difference(y)

移除两个集合中都存在的元素：

#set.difference_update(set)
#在头set中移除头set与尾set均存的元素
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
x.difference_update(y) 
print(x)

提示：

可以用大括号({})创建集合。注意：如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典，下一节我们会介绍这个数据结构。
```
len(s)计算集合元素个数
```
```
s.clear()清除集合内全部元素
```
x in set 判断元素是否存在集合之中

set.copy()拷贝一个集合#不会被discard在后面删除某个元素影响

```
set.discard(value)#删除指定元素
```

set.intersection(set1, set2 ... etc)#返回集合交集，这是创建了一个新集合

set.intersection_update(set1, set2 ... etc)#这个也是放回交集，但是是在原来的set基础上，返回公有的元素

set.symmetric_difference(set)#放回两个集合中不重复的元素构成新集合，所以前面要有载体

set.symmetric_difference_update(set)#移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中，不需要前载体

set.isdisjoint(set)#判断两个集合是否包含相同的元素，返回布尔值，包含是False，不包含True

set.issubset(set)#判断指定集合是否为该方法参数集合的子集

set.issuperset(set)#判断该方法的参数集合是否为指定集合的子集

set.pop()#随机移除元素，一般为最后一个

set.remove(value)#和regard一样，只是在删除一个不存在的元素时会报错

set.update(set)#给集合添加元素，比add强，在于可以添加集合

set.union(set1, set2...)#创建一个新集合，值为交集，所以前面要载体

补充：递推式

List：

names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
new_names = [name.upper()for name in names if len(name)>3]#name.upper()是表达是，是后面穿来
#的name需要执行的一个表达式；name是定义的一个变量，是执行递推式的一个桥梁；names是原list；if 后面
#接的是从names取的name需要执行的判断句
print(new_names)#list的递推式

dict：

dic = {x: x**2 for x in (2, 4, 6)}#解释看list吧，一样的，就是开始写法不同

set：

setnew={x for x in 'asjdhsfhkakfg' if x not in 'abcdef'}

一些相关函数使用示例（add）

斐波那契数实例(循环结构操作)：

#联合赋值：n=b，m=a+b;a=n,b=m;
#while可以搭配else语句
a, b = 0, 1#赋值型语句
while b < 10:#python中的语句使用英文':'作为语句延续
    print(b)
    a, b = b, a+b#python的联合赋值

end关键字的使用：

——（将结果输出到同一行，或者在输出的末尾添加不同的字符）

#关于end关键词的示例
#对应python，一定要注意段前间隔！
a,b=0,8
while b<1314:
   print(b,end='game over')#实验最好的那个数据
   a,b=b,a+b

条件语句if – elif – else：

——if-elif语句也是可以实现嵌套的（报错请使用else）

#对应Python的条件语句，是elif
#书写的格式也是使用英文':'
#常见的操作运算符<,>,<=,>=,!=,==
age = int(input("请输入你家狗狗的年龄: "))
print("")
if age <= 0:
   print("你是在逗我吧!")
elif age == 1:
   print("相当于 14 岁的人。")
elif age == 2:
   print("相当于 22 岁的人。")
elif age > 2:
   human = 22 + (age - 2) * 5
   print("对应人类年龄: ", human)

### 退出提示
input('please press the Enter')

循环语句（此处使用for示例，while在上面已经说过了）

#基本格式for <variable> in <sequence>:

#     <statements>

#else:

#    <statements>

sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:  #先是对变量取值，此处也使用:
    if site == "Runoob": #对变量是否满足条件进行判断
        print("菜鸟教程!")
        break   #关键词break跳出循环，也可以使用continue，用法与c一样
    print("循环数据 " + site)
else:#这个是一个特别特殊的，可以验证对应的for循环是否正常循环
    print("没有循环数据!")
print("完成循环!")

对于循环for，我们常常涉及到一个range函数：

#遍历数字序列，可以使用内置range()函数
#range(起始数，终止数，间隔)
#它会生成数列
for x in range(5)#产生数列从0到第五个数（包括第五个数）
#对于range(5)的解释是 range(0,5)
#从零开始 到5但不包括五
#可以用索引的知识去理解
for x in range(5,9)#这个输出是5，6，7，8
for x in range(3,21,3)#这个输出是3，，6，9，12，15，18
#range()和len()函数以遍历一个序列的索引
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a))#len()是索引查看的关键词

对于循环for，我们常常涉及到一个pass语句：

——Python pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句：

#pass语句就是一个占位的语句
#没有什么特别作用，是给空语句
#唯一作用就是当你写源码时，可以在你思路未好时先占位
for letter in 'Runoob': 
   if letter == 'o':
      pass
      print ('执行 pass 块')
   print ('当前字母 :', letter)
 
print ("Good bye!")

迭代器：

迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。
字符串，列表或元组对象都可用于创建迭代器

1.创建迭代器（iter()用法&next()）：这个是用列表对象

ist=[1,2,3,4]
it=iter(ist)#使用关键词iter键列表ist创建为迭代器
print(next(it))#使用关键词next对迭代器的下一给值进行输出

2.常常与循环for搭配，形成遍历迭代：

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")

3. 迭代器（用一个类，在里面写构造函数去创建迭代器）

#class是类的关键词
#class类里的构造函数，会在初始化之前运行
#类似于Python 的构造函数为 __init__(), 它会在对象初始化的时候执行
class MyNumbers:    
  def __iter__(self):  #在类的构造函数之中实现__iter__方法创建一个特殊的迭代器对象
    self.a = 1#对迭代器中的第一个值赋值
    return self#放回第一个值给myclass
 
  def __next__(self):  #并且迭代器对象实现了 __next__() 方法
    if self.a <= 20:  #使用判断和 StopIteration 异常标识去判断迭代完成
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration  #防止无限循环的出现
 
myclass = MyNumbers()#使用类的构造函数
myiter = iter(myclass)#将myclass创建为迭代器
 
for x in myiter: #遍历输出
  print(x)

生成器：

生成器是一个返回迭代器的函数
使用了 yield 的函数被称为生成器（generator）
调用一个生成器函数，返回的是一个迭代器对象

import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0 #因为里面存在yield函数；定义一个变量counter是因为要限制循环
    while True:
        if (counter > n): 
            return
        yield a  #在这里第一次运行返回a之后，通过迭代器去进行判断
        a, b = b, a + b #下次进入循环会从这里先开始
        counter += 1 
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration: #结束运行
        sys.exit()

函数

简单的一些Python函数解释：

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明（即写一个函数作用的解释）
函数内容以冒号 : 起始，并且缩进
return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None

1.基本语法：

def 函数名（参数列表）:
#这个里面可以写点函数使用介绍
    函数体

2.实例及函数调用的介绍：

def printme(st):  #这里定义了一个自定义函数  1/3/6
    # 打印任何传入的字符串
    print(st)#4/7
    return #返回了None2次


# 调用函数
printme("我要调用用户自定义函数!") #2
printme("再次调用同一函数") #5

3.参数的传递：

在 python 中，类型属于对象，对象有不同类型的区分，变量是没有类型的

a=[1,2,3]#其实你也可以理解变量a是一个指针，它会指向对象的类型

#其中a是变量，[1,2,3]是对象

类型分为可变类型和不可变类型：

·在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象

·不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a

·可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了

对于可变与不可变类型的实例分析：

#这个是一个不可变类型的实验

def change(a):
    print(id(a))   # 指向的是同一个对象#同时我们用id去验证是否和原地址一样
    a=10
    print(id(a))   # 一个新对象，最后你会发现它的地址改变了
 
a=1
print(id(a)) #这个是打印出原来a的内存地址
change(a)

#对于可变类型的实验演示
def changeme( mylist ):  #参数类型是list
   "修改传入的列表"
   mylist.append([1,2,3,4])#末尾增加函数
   print ("函数内取值: ", mylist)
   return
 
mylist = [10,20,30]
changeme( mylist )#在这里调用changeme函数
print ("函数外取值: ", mylist) #用这一个print语句去验证是否可变

4.正式的参数类型：

必需参数：必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

示例：参考上基本语法的哪一个源码

关键词参数：使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值

示例：

def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )#如果使用关键词用等号连接后不需要在意顺序

默认参数：调用函数时，如果没有传递参数，则会使用默认参数

def printinfo( name, age = 35 ): #在这里面35就是默认参数

不定长参数：能处理比当初声明时更多的参数

一些小提示：

被传入给参数的值是按顺序传入（如果没有关键字）
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数
对于*a,如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量
加了两个星号 ** 的参数会以字典的形式导入
如果单独出现星号 * 后的参数必须用关键字传入

def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )#第一个会被传入70，第二个和第三给以元组的形式传入

#此源码演示以字典形式传入
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

def f(a,b,*,c):
    return a+b+c

f(1,2,3) #报错
f(1,2,c=3)#正确

5.匿名函数：Python 使用 lambda 来创建匿名函数

lambda 只是一个表达式，函数体比 def 简单很多
lambda 的主体是一个表达式，而不是一个代码块
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数

语法结构：lambda [arg1 [,arg2,.....argn]]:expression

基本使用示例：

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2#逗号之前写参数，逗号之后写表达式
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

匿名函数封装：在函数内封装

一：

def myfunc(n):
  return lambda a : a * n#是将封装在函数里的匿名函数传出去
 
mydoubler = myfunc(2)#在匿名函数传给myfunc后 mydiybler=lambda a: a*2
mytripler = myfunc(3)#同理
 
print(mydoubler(11))#这里写的是mydoubler，实际上就是匿名函数
print(mytripler(11))#同理

二：

#这里我们测试的是一个匿名函数和def的杂交
def fun(a, b, opt):#这个opt计算让后面可以输入功能
    return opt(a, b)#我估计这里就是可以讲到函数嵌套了
d=fun(1, 2, lambda x, y: x * y+1)#需要一个值的接收器
print(d)

6.return语句的使用：语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None

7.强制位置参数（这个是3.8新增的）

在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)

写法：1. f(10, 20, 30, d=40, e=50, f=60) #True

2. f(10, b=20, c=30, d=40, e=50, f=60) # b 不能使用关键字参数的形式

3. f(10, 20, 30, 40, 50, f=60) # e 必须使用关键字参数的形式

8. eval()函数的用法：

基本语法： eval(expression, globals=None, locals=None)

注意：

执行一个字符串表达式
globals(变量全局):这里必须得是字典形式（，如果写了globals后，在expression中的值，取字典中对应的key的value）
locals是该参数掌控局部的命名空间，功能和globals类似，不过当参数冲突时，会执行locals处的参数。即同就取locals里的参数

实例参考：

仅表达式

a=10
print(eval('a+1'))#输出的结果即11，10+1

有globals

a=10
g={a:2}
print(eval('a+1',g))#结果是3

3.有globals&locals时

a=10
g={a:2,c:4}
t={a:3,b:1}
print(eval('a+b+c',g,t))#结果是3+1+4

数据结构

1.堆栈：append() pop()

解释：最先进入的元素最后一个被释放（后进先出）

示例：

#使用append()和pop()
#使用方法参考列表组里的介绍
stake[1,2,3]
stake.append(4)
stake.append(5)
stake.pop()
stake.pop()
stake.pop()

2.队列：

解释：在队列里第一加入的元素，第一个取出来

注意：拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）.

#append() pop()
#下面是一个可以控制删除次数的循环结构
#i=1
#while i<4:
#   quene.pop(0)
#   i+=1
quene=['l','j','i']
quene.append('a')
quene.append('g')
quene.append('y')
quene.pop(0)#在移除了原先的索引o之后，原1变为0
quene.pop(0)#这也就解释了为什么这样效率不高，因为后面的索引全在改变
print(quene)

3.列表推导式见上：

基本格式：[3*x for x in list if expression]
一些使用推到式的技巧：1.如果希望表达式推导出一个元组，就必须使用括号

示例一：

list1=[1,2,3]#小玩法
list2=[[x,x*2] for x in list1]#还是需要一个接收器来收推导式得到的列表
print(list1)
print(list2)

示例二：

freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
[weapon.strip() for weapon in freshfruit]
#解释strip()的用法
#strip()删除移除字符串头尾指定的字符（默认为空格或换行符)
#示例：
#str = "123abcrunoob321"
#print (str.strip( '12' ))  # 字符序列为 12

示例三：

list1=[1,2,3]
list2=[4,5,6]
newlist=[x*y for x in list1 for y in list 2]#可以使用多个for，in，if
print(newlist)

补充介绍一个round()函数的使用方法：

#round( x [, n]  )
#[]不是需要你输入的，只是告诉你[]里是可以有也可以无的
#x是一个浮点数，n是你想保留的小数位数
print "round(80.23456, 2) : ", round(80.23456, 2)

示例四：嵌套列表解析

矩阵列表的转换pass：

#这里需要去看一点矩阵的知识
#存疑，为什么新的row取的值是原row的第一个，第二个...
matrix = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
]#这是一个矩阵
newmatrix=[[row[i] for row in matrix] for i in range(4)]#range(4)是0,1,2,3
print(newmatrix)

4.del语句的使用：

解释：

del 语句可以从一个列表中根据索引来删除一个元素，而不是值来删除元素
del(data):删除整个list。
del(data[i]):删除data中索引为i个数据
del(data[i:j]):删除data中第i个数据到第j个数据之前（不含j）的数据

示例演示：

date=[1,2,3,4,5]
del (date[i])#删除索引为i的元素
del (date[a:b])#删除从索引a到索引b的元素（不包括b）
del (date)#删除全部元素，变成空列表

5. 遍历技巧

对于字典中遍历时 .items()

解释：将字典按key:value输出

c = {"lui":"大哥","外号":"霸气外露"}
print(c) 		 		 # {'lui': '大哥', '外号': '霸气外露'}
print(c.items()) 		 # dict_items([('lui', '大哥'), ('外号', '霸气外露')])

print(type(c)) 			 # <class 'dict'>
print(type(c.items()))   # <class 'dict_items'> 

for a, b in c.items():
    print(a,"：",b)
    print(type(a),type(b))
# for 循环 输出结果为
'''
lui ： 大哥
<class 'str'> <class 'str'>
外号 ： 霸气外露
<class 'str'> <class 'str'>
'''

对于序列中遍历时 enumerate()

解释：将索引位置和对应值全部输出

for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i, v)

同时遍历两个或更多的序列 zip()

解释：合并多个序列，使用','隔开，方便遍历

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
       print('What is your {0}?  It is {1}.'.format(q, a))#这里使用了一个函数.format

反向遍历一个序列 reversed()

for i in reversed(range(1, 10, 2)):
      print(i)

排序 sorted()

basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for f in sorted(set(basket)):
      print(f)

模块

定义：模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py

模块导入的方法：

'''
1.定义一个模块(这个模块是只有一个name)
def name(expression):
    return result
2.将模块全部导入方法
       A
import math #使用这种方法导入模块后,使用里函数的时候需要加上模块的前缀
a=math.sin(math.pi\2)//看这
print(a)
       B
from mod import *
3.将模块部分导入的方法
from mod import a particular mod#多个函数的话就使用逗号
#例如：
from math import sin
'''

如果你打算经常使用一个函数，你可以把它赋给一个本地的名称（上面有一个匿名函数的就是这样使用的）
```
#fib是一个本地名称
#fibo.fib是一个函数
fib = fibo.fib
```

如果对于某个模块的某个函数，不想让它被引用时使用__name__属性

$库文件.py
#在此文件使用函数a()时会输入第一条print
#如果别的.py文件引入此库中的a()函数，会运行第二条print
def a():
   if __name__ == '__main__':
    print('程序自身在运行')#如果是在自身运行即为此语段
   else:
    print('我来自另一模块')#被别的文件引入就是这个语段

找到模块内定义的所有名称 dir()函数
```
import shi
shi.a()
a=dir(shi)
print(a)
```
包：管理 Python 模块命名空间的形式（类似与模块写函数）

引用的方法：import 包名.主模块名.次模块名.等

解释：这里是一个多重包，就是可以在某一层的包中加一个文件 __init__.py才称为包，同时里面应该包含一个__all__ 的列表变量，那样在from package import * 的时候就把这个列表中的所有名字作为包内容导入

实例：这样在这个包里面的各个对于的模块就被导入了(echo.py...被导入)
__all__ = ["echo", "surround", "reverse"]

输入和输出

输出：

最常见的两种输出格式：表达式语句和 print() 函数

如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。
如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现

输出一:str()

print(str(1/7))#输出是'0.。。。。'

输出二：repr()

#将对象转化为供解释器读取的形式
#repr() 的参数可以是 Python 的任何对象
 s = 'Hello, python'
 repr(s)#输出"'Hello, python'"

输出三：输出一个平方与立方的表（方法一）

#打印一个表
#里面有几个函数.rjust()   .center()   .ljust() 
for x in range(1, 11):
     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
     # 注意前一行 'end' 的使用
     print(repr(x*x*x).rjust(4))

关于一些宽度填充函数的使用：.center .rjust . ljust .zfill

举例一：center(width[, fillchar])#这一个和.rjust .ljust 是一个类型
#width是宽度
#fillchar是补充的字符 我喜欢用'*',一般是空格
print("God".center(7,'*'))
#输出结果：**God**
举例二：zfill()
#.zfill()也是填宽度
#不过是在左边填充0
print('12'.zfill(7))

实例：输出一个平方与立方的表（方法二）*推荐方法

for x in range(1, 11):
       print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))

关于.format前 {}使用的几种情况

"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序 'hello world'
"{0} {1}".format("hello", "world") # 设置指定位置 'hello world'
"{1} {0} {1}".format("hello", "world") # 设置指定位置 'world hello world'
print("网站名：{name}, 地址 {url}".format(name="CSDN", url="CSDN"))
print("网站名：{name}, 地址 {url}".format(**site))#site = {"name": "菜鸟教程", "url": "www.runoob.com"}/字典
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # 索引的时候"0" 是必须的, my_list = ['CSDN', 'CSDN']

.format() 使用的一些tips
"{[index]:[^].[width]f}".format(3.1415926)
b、d、o、x 分别是二进制、十进制、八进制、十六进制，没有就是str型

^, <, > 分别是居中、左对齐、右对齐，后面带宽度
: 后传入一个整数, 可以保证该域至少有这么多的宽度。用于美化表格时很有用
table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
for name, number in table.items():#复习.items是遍历字典以key:value的形式输出
    print('{0:10} ==> {1:10d}'.format(name, number))
!a (使用 ascii()), !s (使用 str()) 和 !r (使用 repr()) 可以用于在格式化某个值之前对其进行转化
import math
print('常量 PI 的值近似为： {!r}。'.format(math.pi))
在格式化字典的时候，可以用[]去引入key，从而达到在{}里面用key去格式化的技术，可以防止出错
table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
print('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}'.format(table))
#加0是因为将要被格式化的三个value都是table里，且后面format的括号里的范围最大是0
#如果不想加0，就得告诉编译器，这是一个dict 使用在table前加**即可
#.format(**table)

输出四：% 操作符也可以实现字符串格式化

import math
print('常量 PI 的值近似为：%5.3f。' % math.pi)#和c一样的理解

输入

input() 读取键盘输入

str = input("请输入：")#唯一需要提醒的就是需要一个对键盘输入的接收器
print ("你输入的内容是: ", str)

open() 返回一个 file 对象

基本格式：open(filename, mode)

filename是文件名称
mode决定了打开文件的模式（这里需要参考我的博客图鉴，下面会有点讲解）

三种基础模式：

r（默认模式→只读模式）
w(只写模式)：这个模式是从头开始写文件，原有的会被删除；如果这个文件没被创建，还会创建此文件
a(追加模式)：这个模式会从最底下开始写，不会删除原内容；如果该文件不存在，创建新文件进行写入

模式的改变：

加‘+’在原有的模式基础上加读或写
字母'b'以二进制的格式打开(添加优先级高于'+')

示例：rb+:读写模式，且以二进制的模式打开

创建txt和写txt的实例：


# 打开一个文件
#如果是用编译器写，注意你的换行符\n，因为后面你读的时候需要用上
f = open("路径", "w")
f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
# 关闭打开的文件，这一步不能少，不然你的文件一直是开的
f.close()

3.打开了一个文件后的操作（后面的例子都是打开了一个叫f的文件）

A.f.read(size):将读取一定数目的数据, 然后作为字符串或字节对象返回

·size 是一个可选的数字类型的参数

· 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回

·.read()需要一个接收器哦，然后用就可以打印出来了

B.f.readline(): 从文件中读取单独的一行（\n）

·f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行

·.readline()同样需要一个接收器哦，然后用就可以打印出来了

C.f.readlines(): 将返回该文件中包含的所有行

·f.readlines() 如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割

·每行读取的另外一种方法迭代一个文件对象然后读取每行：

#注意：这个方法很简单, 但是并没有提供一个很好的控制。 因为两者的处理机制不同, 最好不要混用
# 打开一个文件
f = open("f.txt", "r")

for line in f:
    print(line, end='')

# 关闭打开的文件
f.close()

D. f.write(string):将 string 写入到文件中, 然后返回写入的字符数

·在书写的时候用\n去换行

·如果需要看到返回的字符数，用一个变量去接受这个对象，然后输出就可以查看

·如果想一下写多行,writelines()是个不错的选择，就是换行要打/n

·如果要写入一些不是字符串的东西, 那么将需要先进行转换:

f = open("f.txt", "w")
value = ('www.love.com', 14)
s = str(value)#格式转换
f.write(s)

# 关闭打开的文件
f.close()

E. f.tell():返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数

·用一个变量去接受f.tell()再输出就可以看字节数了（推荐小白去查一下字节）

G.f.seek():改变文件当前的位置

·f.seek(offset, from_what)

·offset表示移动的字符数，1(向后一个字符)，-1(向前移动一个字符)

·from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾,from_what 值为默认为0

·一般这个是与.write &&.read一起用，用来修改file

E. f.close():调用 f.close() 来关闭文件并释放系统的资源

处理一个文本的文件的一般用法：with关键字

with open('/d/love.txt', 'r') as f:
    read_date=f.read()
f.close

Python file

打开(返回)文件对象的方法：open(filename[,mode])

·如果该文件无法被打开，会抛出 OSError

·使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法

完整的语法格式：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None) 
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

file 对象常用的函数 (上面出现的此处无)

1. file.flush():方法是用来刷新缓冲区的，即将缓冲区中的数据立刻写入文件，同时清空缓冲区，不需要是被动的等待输出缓冲区写入

·为什么设置缓冲区的简单理解：内存必须等待外设输入（输出）一个字节之后，才能再次输出（输入）一个字节，内存中的程序大部分时间都处于等待状态

·该方法没有返回值

使用实例：

#引自https://blog.csdn.net/cumtb2002
# Python File flush() Method with Example
 
# creating a file 
myfile = open("hello.txt", "w")
 
# writing text to the file 
myfile.write("Hello friends, how are you?")
 
# flushing the internal buffer
myfile.flush()
# writing the text again
myfile.write("\nI am good, what about you?")
 
# flushing the internal buffer
myfile.flush()
# writing the text again
myfile.write("\nI am good too, thanks!")
 
# closing the file
myfile.close()
 
# reading content from the file
myfile = open("hello.txt", "r")
print("file content...")
print(myfile.read())
myfile.close()
#总结flush即为让缓冲区的数据更快输入输出，起一个加速的作用

2. fileno():返回一个整型的文件描述符(file descriptor FD 整型)，可用于底层操作系统的 I/O 操作

·返回文件描述符(文件描述符是一个简单的整数，用以标明每一个被进程所打开的文件和socket。第一个打开的文件是0，第二个是1，依此类推)

使用实例：

#有一个.name的函数，是反回值是文件名称的一个函数
#使用.fileno()函数是想查看文件的进程顺序
# 打开文件
fo = open("jiesule.txt", "wb")
print ("文件名为: ", fo.name)
fid = fo.fileno()
print ("文件描述符为: ", fid)
# 关闭文件
fo.close()

3. file.isatty():检测文件是否连接到一个终端设备，如果是返回 True，否则返回 Fals

· 返回值是布尔值

使用实例：

#终段设备是类似与键盘之类的
fo = open("jiesle.txt", "wb")
print ("文件名为: ", fo.name)
ret = fo.isatty()
print ("返回值 : ", ret)
fo.close()

4. file.seek():用于移动文件读取指针到指定位置

· 基本语法：fileObject.seek(offset[, whence])

offset -- 开始的偏移量，也就是代表需要移动偏移的字节数，如果是负数表示从倒数第几位开始

whence：可选，默认值为 0。给 offset 定义一个参数，表示要从哪个位置开始偏移；0 代表从文件开头开始算起，1 代表从当前位置开始算起，2 代表从文件末尾算起（这里需要注意，只有当文件以二进制的方式打开的时候才有1或2）

一般与.tell()连用，tell()可以查看文件偏移量

如果操作成功，则返回新的文件位置，如果操作失败，则函数返回 -1

使用实例：


fo = open("D:\python file practice\oo.txt", "wb")
fo.write(b'0123456789abcde')
a=fo.seek(5)
b=fo.seek(-3,2)#这里如果没有2告诉编译器是从尾开始，会报错
print ("文件名为: ", fo.name)
print(a,b)
fo.close()

作用二：循环读取文件的内容

· 实现原理：当你使用read//readline后，文件指针已经不在开头，使用.seel(0,0)即可恢复指针在最开始

实例：

#这里mode的选择用r/r+
#如果使用w/w+是写，会清空原内容，即无法使用read/readline
#如果使用a/a+是追加，由于指针在末尾，也无法读,但也可以修改
#在开始使用read/readline之前，使用seek(0)将指针移到最开始
fo = open("D:\python file practice\ss.txt", "r+")
a=fo.readline()
print(a)
fo.seek(0)
b=fo.readline()
print(b)
fo.close()

5. file.tell():返回文件的当前位置，即文件指针当前位置

·返回文件的当前位置

使用实例：

fo = open("D:\python file practice\ljw.txt", "a+")
fo.seek(0)
c=fo.tell()#这个函数是查看指针位置的函数
print(c)
a=fo.readline()
print(a)
fo.seek(0)
b=fo.readline()
print(b)
fo.close()

6. file.truncate():用于从文件的首行首字节开始截断，截断文件为 size 个字节，无 size 表示从当前位置截断；截断之后 V 后面的所有字节被删除，其中 Widnows 系统下的换行代表2个字节大小

·基本语法：fileObject.truncate( [ size ])

使用实例：

fo = open("D:\python file practice\ljw.txt", "r+")#文件里面有1/n 2/n 3/n
a=fo.readline()
print(a)
#此例为带size参数，使用时一定主要不同的类对应的字符数
fo.truncate()#因为里面无参数size,即从当前位置截断，namely，将1/n干掉
b=fo.readlines()#输出全部行，验证是否被截断
print(b)
fo.close()