【Python】自学笔记

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言参见

(https://www.imooc.com/learn/1261) (https://www.runoob.com/python/python-tutorial.html)

---

1.整型-地板除

Python除了普通除法以外，还有一个特殊的除法被称为地板除，对于地板除，得到的结果会忽略纯小数的部分，得到整数的部分，地板除使用//进行。

10//4 # ==> 2
10//2.5 # ==> 4.0
10//3 # ==> 3

2.float型-小数点位数使用

Python计算小数的时候，经常需要保留小数点后若干位，可以使用round()函数来处理，这里先了解round的调用方式，使用两个参数，第一个是需要保留小数点位数的数值，第二个是保留的位数。

num = 10 / 3
print(num) # ==> 3.3333333333333335

#使用round保留两位小数

round(num, 2) # ==> 3.33

3.布尔类型

在Python中，布尔类型还可以与其他数据类型（字符串，数字等）做 and、or和not运算，请看下面的代码：

a = Trueprint(a and 0 or 99) # ==> 99

得到的计算结果不是布尔类型，而是数字99，这是为什么呢？
因为Python把0、空字符串和None看成False，其他数值和非空字符串都看成True，所以：True and 0计算结果是0 继续计算0 or 99计算结果是 99 因此，结果是99。需要注意的是，not计算的优先级是高于and和or的。True and not False # ==> True
在上述布尔计算中，先计算not False = True，然后再计算True and True，因此得到True的结果。
请运行如下代码，并解释打印的结果：

a = 'python'
print('hello,', a or 'world')    
 #('hello,', 'python')
b = ''print('hello,', b or 'world')     #('hello,', 'world')

1. 在计算a and b时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。
2. 在计算a or b时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。

4. 字符串转义

字符串可以用’ '或者" "括起来表示。如果字符串本身包含’怎么办？比如我们要表示字符串 I’m OK ，这时，可以用" "括起来表示：“I’m OK"类似的，如果字符串包含”，我们就可以用’ '括起来表示：'Learn “Python” in imooc’但是，如果字符串既包含’又包含"怎么办？这个时候，就需要对字符串中的某些特殊字符进行“转义”，Python字符串用\进行转义。

1. 要表示字符串Bob said “I’m OK”.
   由于’和"会引起歧义，因此，我们在它前面插入一个\表示这是一个普通字符，不代表字符串的起始，因此，这个字符串又可以表示为

'Bob said \"I\'m OK\".'

注意：转义字符 \不计入字符串的内容中。常用的转义字符还有：\n表示换行\t 表示一个制表符\表示 \ 字符本身

2. 请在Python中输出以下字符串

special string: ', ", \, \\, \n, \t
参考答案：
s = 'special string: \', ", \\, \\\\ , \\n, \\t'
print(s)

3. r’(_{_})/ (_{_})/’
   但是r’…‘表示法不能表示多行字符串，也不能表示包含’和 "的字符串。
   如果要表示多行字符串，可以用’’’…’’'表示：

'''Line 1
Line 2
Line 3'''

上面这个字符串的表示方法和下面的是完全一样的：

'Line 1\nLine 2\nLine 3'

还可以在多行字符串前面添加r，把这个多行字符串也变成一个raw字符串：

r'''Python is created by "Guido".
It is free and easy to learn.
Let's start learn Python in imooc!'''

5.Python的字符串

format字符串是Python程序重要的数据类型，到目前为止，我们输出的字符串的内容都是固定的，但有时候通过字符串输出的内容不是固定的，这个时候需要使用format来处理字符串，输出不固定的内容。
字符串format由两个部分组成，字符串模板和模板数据内容组成，通过大括号{}，就可以把模板数据内容嵌到字符串模板对应的位置。

字符串模板

template = ‘Hello {}’

模板数据内容

a= 'World’result = template.format(a)
print(result)
template = ‘Hello {3}, Hello {2}, Hello {1}, Hello {0}.’
result = template.format(‘World’, ‘China’, ‘Beijing’, ‘imooc’)
print(result)

指定{}的名字w,c,b,i

template = ‘Hello {w}, Hello {c}, Hello {b}, Hello {i}.’
world = 'World’
china = ‘China’
beijing = ‘Beijing’
imooc = ‘imooc’

#指定名字对应的模板数据内容
result = template.format(w = world, c = china, b = beijing, i = imooc)
print(result)

6.其他字符串知识

中英混合要加# coding: utf-8

print(“这是一句中英文混合的Python字符串：Hello World!”)

读取字符串

s = ‘ABCDEFGHIJK’
abcd = **s[0:4] **# 取字符串s中的第一个字符到第五个字符，不包括第五个字符
print(abcd) # ==> ABCD

格式化输出，if elif

age = 2          2   #age = int(input("请输入你的年龄:"))
if age>=18:    
print("adult,%d" %(age))  #adult,22
else：
age = 1
if age >= 18:
    print('adult')
elif age >= 6:  #不用加6—18，顶格写  
    print ('teenager')
elif age >= 3:
    print ('kid')
else:
    print ('baby')

for，while循环

s = 'ABCD'
for ch in s:
    print(ch) # 注意缩进

在上述代码中，ch是在for循环中定义的，意思是把字符串s中的每一个元素依次赋值给ch，然后再把ch打印出来，直到打印出字符串s的最后一个字符为止。
L = [75, 92, 59, 68, 99]**请利用for循环计算出平均成绩。**利用一个sum变量累加就可以计算出总成绩。

L = [75, 92, 59, 68, 99]
sum = 0.0  #平均可能小数
for x in L:
    sum = sum + x
print(sum / len(L))

while num <= 100:
假如希望输出字符串s中第10个以后的字符，而不是所有字符，这个时候， 我们可以使用continue跳过前面的9个字符。

s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
num = 1
for ch in s:
     if num < 10:
           num = num + 1
           continue # 错误条件时，跳过后续循环代码，重新返回上面继续下一次循环
     print(ch)
     num = num + 1

"IndentationError: unexpected indent"的解决方法. python是一种对缩进非常敏感的语言，最常见的情况是tab和空格的混用会导致错误，或者缩进不对，而这是用肉眼无法分别的。

7.列表

列表(list)是一种有序的容器，放入list中的元素，将会按照一定顺序排列。可以同时放入任意类型的数据。

L = ['Alice', 66, 'Bob', True, 'False', 100]
print(L)

请使用迭代的方式按顺序输出列表 L = [‘Alice’, 66, ‘Bob’, True, ‘False’, 100] 的偶数位置的元素。

num = 0L = ['Alice', 66, 'Bob', True, 'False', 100]for item in L:    num = num + 1    if num % 2 != 0:        continue    print(item)

sort()

**五名同学的成绩可以用一个list表示：L = [95.5, 85, 59, 66, 72]，请按照索引的方式分别打印出第一名、第二名、第三名。
**L = [95.5, 85, 59, 66, 72]
L.sort(reverse=True) #只写L.sort( )是从小到大排序,括号中的reverse=Ture将其改为从大到小排序
print(L[0:3]) 或者 print(L[-5:-2])

append(),insert() 列表插入

append()方法总是将元素添加到list的尾部。
names.append(‘Candy’)
insert()方法需要两个参数，分别是需要插入的位置，以及需要插入的元素。 names.insert(2, ‘Candy’)#插入第三个位置
新来报到3名同学分别是’Zero’, ‘Phoebe’, ‘Gen’，请综合利用append()方法，insert()方法，把三个同学的名字按首字母顺序插入到列表里去。

L=['Alice', 'Bob', 'Candy', 'David', 'Ellena']
O=['Zero', 'Phoebe', 'Gen']
z=O.sort()
for i in O:  #注意是O不是z。sort方法，返回的是原列表，所以z列表并不存在（会返回NONE） 
        L.append(i)  # i已经是字符串，append里面不用再使用列表提取字符串，而是直接使用i即可，而不是z[i]
        print(L)
        L2 = L.pop()   #默认删除列表的最后一个元素，并返回。
        L2= L.pop(2)#或者
        del list[2:4]#删除第3-4个元素

zip和key=lambda

班上某次考试，[‘Alice’, ‘Bob’, ‘Candy’, ‘David’, ‘Ellena’] 的成绩分别是 89, 72, 88, 79, 99，请按照成绩高低，重新排列list中同学名字的顺序。

students = ['Alice', 'Bob', 'Candy', 'David', 'Ellena'] 
score = [89, 72, 88, 79, 99]
sort =sorted(zip(students,score),key=lambda x:x[1],reverse=True)
print(sort)
print(zip(*sort)[0])

#zip() 函数将两个列表中的元素一一配对，生成一个由元组组成的可迭代对象。将姓名和成绩配对成元组列表，例如 [(‘Alice’, 89), (‘Bob’, 72), …]。
sorted(iterable, key=None,reverse=False)

1. iterable: 必需参数。要排序的可迭代对象（如列表、元组、字符串等）。
2. key:可选参数。用于从每个元素中提取一个用于排序的值。它是一个函数，接受一个元素并返回一个值。sorted() 将根据这个值进行排序。默认值是 None，即直接对元素进行比较。key=lamda x：len（x）就是按照x的长度大小排序。这里是按照x的第二个元素值大小排序。lambda 是 Python 的一个关键字，用于创建匿名函数（即没有名字的函数）。x 是函数的输入参数，它表示列表中的每个元素。x[1] 是一个表达式，表示从输入参数 x 中提取第二个元素。
3. reverse:可选参数。布尔值，指定是否按降序排序。默认值是 False，即升序排序。如果设置为 True，则按降序排序。
4. 返回值sorted() 返回一个新的列表，其中包含了排序后的元素。原始的可迭代对象不受影响。
   *sort 通过解包将排序后的元组列表传递给 zip()。
   zip() 函数将多个可迭代对象的相同位置元素打包在一起。
   zip(*sort)[0]：通过索引 [0] 提取第一个元组，即学生名字的元组。

二维列表：

alice_scores = [100,89,92]
bob_scores = [70,65,81]
candy_scores = [88,72,77]
all_scores = [alice_scores, bob_scores, candy_scores]
score = all_scores[1][2]    #all_scores[1]得到Bob的最近三次成绩的列表 【70，65，81】，再通过下标[2]，则可以得到Bob第三次 81
print(score)# ==> 81

8.元组

请创建一个tuple，顺序包含0~9的十个数，并尝试将其转换为列表list。

t=(0,1,2,3,5,4,6,7,8,9)#元组直接括号，不可变，性能好。可以互相转换。
print(t)      # (0, 1, 2, 3, 5, 4, 6, 7, 8, 9)
l=list(t)
print(l)      # [0, 1, 2, 3, 5, 4, 6, 7, 8, 9]

tuple和list一样，可以包含 0 个、1个和任意多个元素。

包含 0 个元素的 tuple，也就是空tuple，直接用()表示：

T = ()print(T)     # ==> ()

接着，我们创建包含一个元素的tuple

T = (1)print(T)     # ==> 1

这和我们期望的输出有些差异，为什么包含一个元素的元组打印出来之后没有小括号，而是只有一个数字1。
因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果(1)被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。
因此，要定义只有一个元素的tuple，需要在元素后面添加一个逗号,。

T = (1, )print(T) # ==> (1, )

有多少个tuple。T = ( (1+2), ((1+2),), (‘a’+‘b’), (1, ), (1,2,3,4,5) )

T = ((1+2),  ((1+2),), ('a'+'b'), (1, ), (1,2,3,4,5))
num = 0
for t in T:
    if isinstance(t,tuple):
            num += 1
            print(num)

3个。第一个元素(1+2)，第三个元素(‘a’+‘b’)，计算的结果分别是数字3和字符串ab，不是tuple。

isinstance(object, classinfo)

object: 需要检查的对象。
classinfo: 可以是单个类、数据类型，或者一个包含多个类或数据类型的元组。返回值返回 True，False。
例二

y = "Hello"
print(isinstance(y, (int, str))) # True，因为 y 是 str 类型，符合 (int, str) 中的一个 
print(isinstance(y, (int, list))) # False，因为 y 既不是 int 也不是 list

例三

class Animal: pass 
class Dog(Animal): pass
my_dog = Dog() 
print(isinstance(my_dog, Dog)) # True，因为 my_dog 是 Dog 类型的实例 
print(isinstance(my_dog, Animal)) # True，因为 Dog 是 Animal 的子类

count()方法

count()方法用来统计tuple中某个元素出现的次数。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(1)) # ==> 3
print(T.count(5)) # ==> 1

对于不存在的元素，count方法不会报错，而是返回0.

index()方法

index()方法可以返回指定元素的下标，当一个元素多次重复出现时，则返回第一次出现的下标位置。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
T.index(9) # ==> 10
T.index(5) # ==> 8
T.index(1) # ==> 0 
# 多次出现，返回第一次出现的位置

注意，index()方法和count()方法不一样，当指定的元素不存在时，使用index()方法Python会报错。

Python的可变tuple

对于tuple，它和list一个最大的不同点就是tuple是不可变的，tuple里面的元素，也是不可替换的。但是这针对的是仅包含基础数据类型（数字类型、布尔类型、字符串类型）的数据，对于组合数据类型，则不受这个约束
T = (1, ‘CH’, [3, 4])第三个元素是列表类型的，412478我们尝试修改第三个元素的数据。
T = (1, ‘CH’, [3, 4])L = T[2] #访问tuple用中括号，赋值给T，[3,4]为list，为引用类型，当其他变量赋其值的时候，赋的其实是他的一个内存地址，指向[3,4]。也就是**所说的L和T[2]其实指向了一个内存地址。
**print(L) # ==> [3, 4]#尝试替换L中的元素
L[1] = 40
print(L) # ==> [3, 40]
print(T) # ==> (1, ‘CH’, [3, 40])这是因为虽然tuple中的list元素改变了，但是tuple本身指向的list仍然是同一个list，list本身并没有改变，改变的只是list里面的一个元素，这是tuple所约束不到的范围。
T = (1, ‘CH’, [3, 4])L2 = [3, 40]
#尝试替换tuple中的list
T[2] = L2
#报错#

9.字典

什么是dict

dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list相反，占用内存小，但查找速度慢。我们可以认为在Python3.6的版本以后，dict是有序的。
python的dict就是专门保存这种映射的，使用dict可以方便的保存“名字”->“成绩”的映射。对于基础数据类型，字符串、数字等，这些都是不可变的，可以作为dict的key，而对于复杂数据类型，经过前面的学习，我们知道tuple是不可变的，list是可变的，因此tuple可以作为dict的key，但是list不可以作为dict的key，否则将会报错。
在dict中，每一项包含一个key和一个value，key和value是一一对应的，在解决上面的问题中，我们可以使用名字作为key，成绩作为value，那么dict的定义如下：
d = { ‘Alice’: 45, ‘Bob’: 60, ‘Candy’: 75, ‘David’: 86, ‘Ellena’: 49}
在定义里，我们使用花括号{}表示这是一个dict，然后key和value之间使用冒号:分割，并且每一组key:value的最后，以逗号,表示这一组的结束。
我们也可以使用以下的方式定义一个dict。
d = dict()
print(d) # ==> {}
不过这种定义方式，默认得到的是一个空dict，需要调用函数往里面添加数据，我们后面会继续学习。

读取dict元素

print(d[‘Bob’]) # ==> 60
print(d[‘Alice’]) # ==> 45
还有一种方法可以通过key来获取对应的value，这种方法不会引起错误，dict本身提供get方法，把key当作参数传递给get方法，就可以获取对应的value，
当key不存在时，也不会报错，而是返回None。
print(d.get(‘Alice’)) # ==> 45
print(d.get(‘Dodo’)) # ==> None
因为通过get方法在代码实现上更加简单，且不会引起错误，因此更加推荐使用get方法来获取dict的元素。
想通过value返回同样value的key呢？就比如在我想知道这个dict里面60分的有谁?

for key,value in d.items():
        if value==60:       
              print(key)
for x in d: # 遍历d的key    
      value = d[x]# x=alice可以理解为value等于d['Alice']    
      if value > 60:        
            print(key, value)

添加dict元素

value可以是任意类型的元素，可以是list、tuple等，假如Mimi近两次成绩分别是72，73，Dodo近两次的成绩分别是88，90，则可以使用赋值语句往dict中添加list元素。
d[‘Mimi’] = [72, 73]
d[‘Dodo’] = [88, 90]
print(d)
此后，如果Mimi、Dodo的第三次成绩也出来了，分别是75，90，则可以先通过key把对应的value查询出来，然后再往类型是list的value中添加第三次的成绩。
d[‘Mimi’].append(75)
d[‘Dodo’].append(90)
print(d)

d = {    'Alice': [45],    'Bob': [60],    'Candy': [75],}add = [[50, 61, 66],[80, 61, 66],[88, 75, 90]]k = 0for i in d:        for j in add[k]:                d[i].append(j)        k += 1print(d)

删除dict元素

pop()方法的参数是dict中的key，当key不存在时，同样会引起错误。比如在上述操作中，已经把Alice的成绩删除了，假如再次pop(‘Alice’)，将会引发错误。
d.pop(‘Alice’)使得即使key不存在时，删除也不会抛异常。

d = {   'Alice': 45,  'Bob': 60,  'Candy': 75, 'David': 86,  'Ellena': 49
}
name = 'Alice'
if name in d.keys():
    d.pop(name)
else:
    print('{} not in d'.format(name))  #如果提前删除alice，输出Alice not in d, name的值赋给了模板中的{}
    print(d)

10.什么是set

dict的key是不重复的，当我们往dict里添加一个相同key的value时，新的value将会覆盖旧的value。
有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。set和list类似，拥有一系列元素，但是set和list不一样，set里面的元素是不允许重复的，而list里面可以包含相同的元素；set与list的另一个区别是，set里面的元素是没有顺序的。
创建set的方式是使用set()，并传入一个list，list的元素将会被转换成set的元素。

s = set([1, 4, 3, 2, 5])
print(s) # ==> set([1, 2, 3, 4, 5])

需要注意的是，上述打印的形式类似 list， 但它不是 list，仔细看还可以发现，打印的顺序和原始 list 的顺序有可能是不同的，因为set内部存储的元素是无序的。重复的元素都被去掉了，这是set的一个重要特点。

Python读取set元素

names = [‘Alice’, ‘Bob’, ‘Candy’, ‘David’, ‘Ellena’]
name_set = set(names)
‘bob’ in name_set # ==> False
#这是因为set元素是区分大小写的，必须大小写完全匹配，才能判断该元素在set里面。

Python添加set元素

set提供了add()方法
name_set.add(‘Gina’)
print(name_set) # ==> set([‘Gina’,如果添加一个已经存在的元素，不会报错，也不会改变什么。
set提供了update()方法，可以一次性给set添加多个元素。
name=set([])
add=[‘Jenny’, ‘Ellena’, ‘Alice’, ‘Candy’, ‘David’, ‘Hally’, ‘Bob’, ‘Isen’, ‘Karl’]
name.update(add)
print(name)

Python删除set元素

set提供了remove()方法允许我们删除set中的元素。
name_set.remove(‘Jenny’)
如果remove的元素不在set里面的话，那么将会引发错误。
给定一个list，对于list里面的每个元素，如果set中包含这个元素，就将其删除，否则添加到set里面去。

L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
S = set([1, 3, 5, 7, 9, 11])
for i in L:
    if i in S:
            S.remove(i)
    else:
            S.add(i)
print(S)

当元素不存在时，使用discard()并不会引发错误，所以使用discard()是更加高效的一个方法。
name_set.discard(‘Jenny’)
和dict一样，set也提供了clear()方法，可以快速清除set中的所有元素。

集合的子集和超集

s1 = set([1, 2, 3, 4, 5])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
#判断s1是否为s2的子集
s1.issubset(s2) # ==> True
#判断s2是否为s1的超集
s2.issuperset(s1) # ==> True

判断集合是否重合

set提供isdisjoint()方法，可以快速判断两个集合是否有重合，如果有重合，返回False，否则返回True。
s1 = set([1, 2, 3, 4, 5])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
s1.isdisjoint(s2) # ==> False，因为有重复元素1、2、3、4、5

11.什么是函数

在这个文档里面，列举了Python内置的大部分函数，同学们有兴趣可以参考看看。https://docs.python.org/3/library/functions.html
sum()函数接收一个list作为参数，并返回list所有元素之和。
请计算 11 + 22 + 33 + … + 100100。
L = []
x = 1
while x <= 100:
L.append(x * x)
x = x + 1
print(sum(L))
Python定义函数
使用 def 语句，依次写出函数名、括号()、括号中的参数和冒号:
def my_abs(x):
if x >= 0:
return x
else:
return -x

Python函数返回值

有时候函数是没有返回结果的，只写return.这个时候从函数获取到的是一个空值None。除了返回None、一个值以外，函数也可以返回多个值，在函数中，如果需要返回多个值，多个值之间使用逗号分隔即可，但是需要注意顺序。
比如，定义一个函数data_of_square，接收边长一个参数，同时返回正方形的周长和面积。

def data_of_square(side):
    C = 4 * side    
    S = side * side    
    return C, S
    C, S = data_of_square(16)
    print('周长 = {}'.format(C)) # ==> 周长 = 64
    print('面积 = {}'.format(S)) # ==> 面积 = 256
    #也可以使用一个值存储函数返回的多值结果。
    result =data_of_square(16)
    print(result) # ==> (64, 256)	
    注意打印的result，其实它是tuple类型，如果我们需要取出结果中的周长或者面积，使用对应位置的下标就可以获得对应的结果。
    C = result[0]
    S = result[1]
    print('周长 = {}'.format(C)) # ==> 周长 = 64
    print('面积 = {}'.format(S)) # ==> 面积 = 256

如果在一个函数内部调用其自身，这个函数就是递归函数。
举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * … * n，用函数 fact(n)表示，可以看出：
fact(n) = n! = 1 * 2 * 3 * … * (n-1) * n = (n-1)! * n = fact(n-1) * n
所以，fact(n)可以表示为 n * fact(n-1)，只有n=1时需要特殊处理。于是，fact(n)用递归的方式写出来就是。

def fact(n):
      if n==1:        
      return 1
      return n * fact(n - 1)
      isinstance(100, int) # ==> True
      isinstance(100.0, int) # ==> False
      isinstance('3.1415926', str) # ==> True

有了isinstance，就可以优化my_abs函数，不在里面运行出错了。

def my_abs(x):
if not isinstance(x, int) or not isinstance(x, float):        print('param type error.')        return None    if x >= 0:        return x    else:        return -xint('123') # ==> 123int('123', 8) # ==> 83##10进制是123，8进制是83

自主定义的函数时使用默认参数：def power(x, n=2):

Python函数使用可变参数

可变参数即任意个参数的意思，可变参数通常使用*args来表示。
def func(*args):
print(‘args length = {}, args = {}’.format(len(args), args))func(‘a’) # ==> args length = 1, args = (‘a’,)func(‘a’, ‘b’) # ==> args length = 2, args = (‘a’, ‘b’)func(‘a’, ‘b’, ‘c’) # ==> args length = 3, args = (‘a’, ‘b’, ‘c’)完善average()函数，使得当可变参数长度为0的时候，也能正确返回结果。def average(*args): sum = 0 if len(args) == 0: return sum for item in args: sum += item avg = sum / len(args) return avg函数会把可变参数当作tuple去处理，tuple在使用上有一定的局限性，比如有时候想找到特定位置的参数，只能通过下标的方式去寻找，如果顺序发生变化得时候，下标就会失效，函数逻辑就得重新修改实现。## Python函数使用可变关键字参数Python函数提供可变关键字参数，对于可变关键字参数，可以通过关键字的名字key找到对应的参数值，想想这和我们之前学习过的什么类似？是的没错，dict，Python会把可变关键字参数当作dict去处理；对于可变关键字参数，一般使用**kwargs来表示。想要打印一个同学的信息，可以这样处理：def info(**kwargs):print(‘name: {}, gender: {}, age: {}’.format(kwargs.get(‘name’),kwargs.get(‘gender’), kwargs.get(‘age’)))#get为了制造list，也可以直接kwargs[‘names’]info(name = ‘Alice’, gender = ‘girl’, age = 16)## print 输出print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：#不换行输出 print( x, end=" " ) print( y, end=" " )## import 与 from…import在 python 用 import 或者 from…import 来导入相应的模块。将整个模块(somemodule)导入，格式为： import somemodule从某个模块中导入某个函数,格式为： from somemodule import somefunction从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc将某个模块中的全部函数导入，格式为： from somemodule import *import mathresult = math.sqrt(16)print(result) # 输出 4.0from math import sqrtresult = sqrt(16)print(result) # 输出 4.0import module：将整个模块作为一个对象导入到当前命名空间中。模块中的对象通过 module.name 访问，不会与当前命名空间中的其他对象冲突。from module import name：直接将模块中的对象导入到当前命名空间中。可能会与当前命名空间中的其他对象发生命名冲突。print (tinylist * 2) # 打印tinylist列表两次，元组可print (list + tinylist) # 打印两个列表拼接在一起的结果，元组也可Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：Letters[1:4:2][表达式 for 变量 in 列表 if 条件]过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母：pythonnames = ['Bob','Tom','alice','Jerry','Wendy','Smith']new_names = [name.upper()for name in names if len(name)>3] #有赋值print(new_names)[‘ALICE’, ‘JERRY’, ‘WENDY’, ‘SMITH’]想创建只有一个元素的元组，需要注意在元素后面添加一个逗号，以区分它是一个元组而不是一个普通的值，这是因为在没有逗号的情况下，Python会将括号解释为数学运算中的括号，而不是元组的表示。使用字符串及其长度创建字典：实例pythonlistdemo = ['Google','Runoob', 'Taobao']#将列表中各字符串值为键，各字符串的长度为值，组成键值对newdict = {key:len(key) for key in listdemo}newdict{'Google': 6, 'Runoob': 6, 'Taobao': 6}提供三个数字，以三个数字为键，三个数字的平方为值来创建字典：dic = {x: x**2 for x in (2, 4, 6)}dic{2: 4, 4: 16, 6: 36}type(dic)<class 'dict'>set可以进行集合运算a = set(‘abracadabra’)b = set(‘alacazam’)print(a - b) # a 和 b 的差集print(a | b) # a 和 b 的并集print(a & b) # a 和 b 的交集print(a ^ b) # a 和 b 中不同时存在的元素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没有动，只是其内部的一部分值被修改了。