python入门速通基础

介绍

本文将介绍python常用函数，语法，对象类型等等
这一文章是本人做题中遇到的难点和总结，一部分源于网上，一部分自己写的。若有错误，谢谢指出。
一些基础知识来源于链接: python菜鸟

列表（List）

序列是$python$中最基本的数据结构。序列中的每个元素都分配一个数字-它的位置或称索引，第一个索引是$0$，第二个索引是$1$，以此类推。

列表是最常见的$python$数据类型，它可以作为一个方括号内的逗号分隔值出现

列表可以相当c++中的队列和栈的功能，适用性非常强。

列表的数据项不需要具有相同的类型。

创建一个列表，只要把逗号分割的不同的数据项使用方括号括起来即可。

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]

访问列表中的值

使用下标索引来访问列表中的值，同样的你也可以是同方括号的形式截取字符

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]

print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]
# result
list1[0]:  physics
list2[1:5]:  [2, 3, 4, 5]

更新列表

你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项。

list = []          ## 空列表
list.append('Google')   ## 使用 append() 添加元素
list.append('Runoob')
print list
# result
['Google', 'Runoob']

删除列表元素

可以使用$del$语句来删除列表的元素

list1 = ['physics', 'chemistry', 1997, 2000]

print list1
del list1[2]
print "After deleting value at index 2 : "
print list1
# result
['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]

$python$列表脚本操作

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

• $+$和$\ast$

list1 = []
for i in range(5):
 list1.append(i)
print(list1)
list2 = [5,6,7,8,9]

list3 = list1 + list2
list4 = list3 *2
print(list3)
print(list4)
# result
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• len,in_和_for in

list1 = [1,2,3]
print(len(list1))
print(3 in  list1)

for i  in list1:
 print(i,end=' ')
# result
3
True
1 2 3 

元组(tuple)

$python$的元组与列表类似，不同之处在于元组不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号内添加元素，并使用逗号隔开即可。

• 正常创建

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

• 创建空元组

tup1 = ()

• 元组中只包含一个元素时，需要在元素后面添加逗号。

tup1 = (50,)

元组与字符串类似，下标索引从$0$开始，可以进行截取，组合等

访问元组

元组可以使用下标索引来访问元组中的值。

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print "tup1[0]: ", tup1[0]
print "tup2[1:5]: ", tup2[1:5]
# 运行结果
tup1[0]:  physics
tup2[1:5]:  (2, 3, 4, 5)

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

# 以下修改元组元素操作是非法的。
# tup1[0] = 100

# 创建一个新的元组
tup3 = tup1 + tup2
print tup3
# result
(12, 34.56, 'abc', 'xyz')

删除元组

元组中的元素值是不允许删除的，但我们可以使用$del$语句来删除整个元组。

tup = ('physics', 'chemistry', 1997, 2000)

print tup
del tup
print "After deleting tup : "
print tup
# result
NameError: name 'tup' is not defined #tup删除后不存在

元组运算符

与字符串一样，元组之间可以使用$+$号和$\ast$号进行运算，这就意味着他们可以组合和赋值，运算后会生成一个新的元组。

• $+$和$\ast$

a = (1,2,3) + (4,5,6)
b = ('132',)*3
# 这里注意如果写成('123')*3的运行出来的result是132132132
length = len(a)

print(a)
print(b)
print(length)
# result
(1, 2, 3, 4, 5, 6)
('132', '132', '132')
6

• in_和_for in

_in_运算符判断是否在元组中，是的话返回True，否则返回False

_for in_运算符用来遍历元组中所有元素

a = (1,2,3)
s = list(i for i in a)

print ( 3 in a)
print(s)
# result
True
[1, 2, 3]

元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中某一段元素

L = ('spam', 'Spam', 'SPAM!')

print(L[2])
print(L[-1])
print(L[1:])
#result
SPAM!
SPAM!
('Spam', 'SPAM!')

任何无符号的对象，以逗号隔开，默认为元组

a = 1,2,3,4,5
print(type(a))
# result
<class 'tuple'>

字典

字典是一种可变容器模型，且课存储任意类型对象

字典的每一个键值key:value对（key为键，value为值）用冒号:隔开，每个键值对之间用逗号，号分割，整个字典包括在花括号{}中，格式如下：

d = {key1 : value1, key2 : value2 }

注意：dict作为$python$中的关键字和内置函数，变量名不建议命名为$dict$(可命名为dict1，dict2等等)

键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一

zd = {
 'a': 1 , 'b':2 , 'b':3
}
print(zd['b'])
print(zd)
# 运行结果
3
{'a': 1, 'b': 3}

值可以去任何数据类型，但键必须是不可变得，如字符串，数组，元组。

一个简单例子：

tinydict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

也可以这样创建：

tinydict1 = { 'abc': 456 }
tinydict2 = { 'abc': 123, 98.6: 37 }

访问键对应的值：

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

print "tinydict['Name']: ", tinydict['Name']
print "tinydict['Age']: ", tinydict['Age']

如果字典中不存在要访问的值就会报出：KeyRrror

修改字典

• 向字典里添入新内容和修改已有键值对

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

tinydict['Age'] = 8 # 更新
tinydict['School'] = "RUNOOB" # 添加


print "tinydict['Age']: ", tinydict['Age']
print "tinydict['School']: ", tinydict['School']

• 删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

del tinydict['Name']  # 删除键是'Name'的键值对
tinydict.clear()      # 清空字典所有条目
del tinydict          # 删除字典

print(tinydict['Name']) # 由于不存在键值对，会报出KeyError
print "tinydict['Age']: ", tinydict['Age'] 
print "tinydict['School']: ", tinydict['School']

字典键的特性

字典值可以没有限制地取任何$python$对象，既可以是标准地对象，也可以是用户定义的，但键不行

• 不允许同一个键出现两次。创建时如果同一键被赋值两次，后一个值被记住

tinydict = {'Name': 'Runoob', 'Age': 7, 'Name': 'Manni'} 

print "tinydict['Name']: ", tinydict['Name']
# 运行结果
tinydict['Name']:  Manni

• 键必须不可变，所以可以用数字，字符串或元组充当，但是用列表就不行

inydict = {['Name']: 'Zara', 'Age': 7} 

print "tinydict['Name']: ", tinydict['Name']
# 运行结果
TypeError: unhashable type: 'list'

try-except语句块

• 用法：

  try:
   <语句块1>
  except<异常情况1>:
   <语句块2>
  except<异常类型2>: # 这里可以一直写except<类型3，4，5>，也可以将几个异常类型放在一起
   <语句块3>
  else:
   <语句块4>
  finally:
   <语句块5>
  

  • 如果语句块1正常的话执行else中的语句块4，如果异常的话就执行相应异常情况下的语句块；
  • 无论是否异常都会执行finally中的语句块9

海象运算符

• 介绍:

  海象运算符的英文原名叫 Assignment Expresions ，即 赋值表达式。海象表达式由一个 : 和 一个 = 组成，即：:= 。我们一般称作 walrus operator（海象运算符），因为它看起来就是一个海象旋转 90° 而成

• 语法：

  海象运算符的语法格式是：

  (variable_name := expression or value)
  

  即一个变量名后跟一个表达式或者一个值，这个和赋值运算符 = 类似，可以看作是一种新的赋值运算符。

• 用法：

  • 用于 if-else 条件表达式

    a = 15
    if a > 10:
     print('hello, walrus operator!')
    # 用海象表达式
    if a := 15 > 10:
     print('hello, walrus operator!')
    

  • 用于 while 循环

    n = 5
    while n:
     print('hello, walrus operator!')
     n -= 1
    # 用海象表达式
    n = 5
    while (n := n - 1) + 1: # 需要加1是因为执行输出前n就减1了
     print('hello, walrus operator!')
    

  • 用于列表推导式

    nums = [16, 36, 49, 64]
    def f(x):
     print('运行了函数f(x)1次。')
     return x ** 0.5
    print([f(i) for i in nums if f(i) > 5])
    # result
    运行了函数f(x)1次。
    运行了函数f(x)1次。
    运行了函数f(x)1次。
    运行了函数f(x)1次。
    运行了函数f(x)1次。
    运行了函数f(x)1次。
    运行了函数f(x)1次。
    [6.0, 7.0, 8.0]
    

列表推导式

• 列表推导式(又名列表解析)对应的英文是list comprehension，有时也被翻译为列表解析式，是一种创建列表的简洁语法

• 列表推导式包含三个部分，分别是循环次数、想插入的值、判断是否插入的条件

• 

• 例子：用15以内的奇数创建列表

  list1 = [x for in range(0,15) if x % 2 ==1]
  

List的常用函数

简单的函数有：

• cmp（list1，list2） 比较两个列表的元素
• len（list） 列表元素个数
• max（list） 返回列表元素最大值
• min（list） 返回列表元素最小值
• list（seq） 将可迭代容器转换为列表 （如果是字典的话，就只保留键）

接下的函数最好单独一行，不要出现print（list.append()）这样的语句，会打印出None，而不是所期望的值。

1. list1.append(obj)

   • 末尾增加元素

   aList = [123, 'xyz', 'zara', 'abc']
   aList.append( 2009 )
   print ("Updated List : ", aList)
   # result
   Updated List :  [123, 'xyz', 'zara', 'abc', 2009]
   

2. list2.count(obj)

   • 统计obj的个数

   aList = [123, 'xyz', 'zara', 'abc', 123]
   
   print ("Count for 123 : ", aList.count(123))
   print ("Count for zara : ", aList.count('zara'))
   # result
   Count for 123 :  2
   Count for zara :  1
   

3. list3.count(obj)

   • extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

   list1 = [1,2,3,4]
   dict1 = {'a':1,'b':2}
   
   list1.extend(dict1)
   print(list1)
   # result
   [1, 2, 3, 4, 'a', 'b']
   
   aList = [123, 'xyz', 'zara', 'abc', 123]
   bList = [2009, 'manni']
   aList.extend(bList)
   
   print ("Extended List : ", aList)
   # result
   Extended List :  [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']
   

4. list4.index(x[, start[, end]])

   • x-- 查找的对象。
   • start-- 可选，查找的起始位置。
   • end-- 可选，查找的结束位置。

   aList = ['runoob', 'xyz', 'runoob', 'abc']
   
   print ("runoob 索引位置: ", aList.index( 'runoob' ))
   print ("runoob 索引位置 : ", aList.index( 'runoob', 1, 3 ))
   # result
   runoob 索引位置:  0
   runoob 索引位置 :  2
   

5. list5.insert()

   • insert(x，obj) 函数用于将指定对象插入列表的指定位置。（这里的插入是指第x对象的前面）

   aList = [123, 'xyz', 'zara', 'abc']
   blist = [1,2,3,5,6]
   aList.insert(3, blist)
   
   print("Final List : ", aList)
   # result
   Final List :  [123, 'xyz', 'zara', [1, 2, 3, 5, 6], 'abc']
   

6. list6.pop()

   • pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
   • list.pop([index=-1])
   • obj – 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。

   list1 = ['Google', 'Runoob', 'Taobao']
   list_pop = list1.pop(1)
   print("删除的项为 :", list_pop)
   print("列表现在为 : ", list1)
   # result
   删除的项为 : Runoob
   列表现在为 :  ['Google', 'Taobao']
   

7. list7.remove()

   • remove() 函数用于移除列表中某个值的第一个匹配项。
   • list.remove(obj)
   • obj – 列表中要移除的对象

   aList = [123, 'xyz', 'zara', 'abc', 'xyz']
   
   aList.remove('xyz')
   print ("List : ", aList)
   aList.remove('abc')
   print ("List : ", aList)
   # result
   List :  [123, 'zara', 'abc', 'xyz']
   List :  [123, 'zara', 'xyz']
   

8. list8.reverse()

   • reverse() 函数用于反向列表中元素。
   • list.reverse()

   aList = [123, 'xyz', 'zara', 'abc', 'xyz']
   
   aList.reverse()
   print ("List : ", aList)
   # result
   List :  ['xyz', 'abc', 'zara', 'xyz', 123]
   

9. list9.sort()

   • sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
   • list.sort(cmp=None, key=None, reverse=False)
   • cmp – 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
   • key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
   • reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
   • 值得注意的是排序语句只能单独一条不能和其他的语句如print一起使用，如print(list1.sort())不会报错但是打印出来是None。

   def takeSecond(elem):
    return elem[1]
   
   # 列表
   random = [(2, 2), (3, 4), (4, 1), (1, 3)]
   
   # 指定第二个元素排序
   random.sort(key=takeSecond)
   
   # 输出类别
   print('排序列表：')
   print(random)
   # result
   排序列表：
   [(4, 1), (2, 2), (1, 3), (3, 4)]
   

10. list10.extendI(seq)

    • list.extend(seq)
    • seq – 元素列表。

    aList = [123, 'xyz', 'zara', 'abc', 123]
    bList = [2009, 'manni']
    aList.extend(bList)
    
    print ("Extended List : ", aList )
    # result
    Extended List :  [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']
    

字典常用函数

1. cmp(dict1,dict2)

   • 如果两个字典的元素相同返回0，如果字典dict1大于字典dict2返回1，如果字典dict1小于字典dict2返回-1。

   • 先比较字典的长度，然后比较键，最后比较键对应的值

     dict1 = {'Name': 'Zara', 'Age': 7};
     dict2 = {'Name': 'Mahnaz', 'Age': 27};
     dict3 = {'Name': 'Abid', 'Age': 27};
     dict4 = {'Name': 'Zara', 'Age': 7};
     print ("Return Value : %d" %  cmp (dict1, dict2))
     print ("Return Value : %d" %  cmp (dict2, dict3))
     print ("Return Value : %d" %  cmp (dict1, dict4))
     # result
     Return Value : -1
     Return Value : 1
     Return Value : 0
     

2. len(dict2)

   • 计算键的个数

3. str(dict3)

   • 在Python中，使用str()函数可以将字典转换为字符串表示形式。这对于需要将字典的内容以字符串的形式进行输出、保存或传递给其他函数等情况非常有用。

     当你调用str()函数并传入一个字典作为参数时，它会返回一个包含字典内容的字符串。这个字符串的格式与字典结构相似，通常以花括号{}表示，每个键值对用冒号:连接，并且键值对之间用逗号,分隔。

     具体示例如下：

     my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
     my_str = str(my_dict)
     print(my_str)
     

     输出结果：

     {'name': 'John', 'age': 30, 'city': 'New York'}
     

     这样，你就可以在需要将字典转换为字符串的场景中使用str()函数了。比如，你可以将字典保存到文件中，或者将其作为参数传递给需要接受字符串作为输入的函数等。

4. dict4.clear()

   • 用于删除字典内所有元素

   tinydict = {'Name': 'Zara', 'Age': 7};
   
   print ("Start Len : %d" %  len(tinydict))
   tinydict.clear()
   print ("End Len : %d" %  len(tinydict))
   

5. dict5.copy()

   • 返回一个字典的浅复制。

   dict1 =  {'user':'runoob','num':[1,2,3]}
    
   dict2 = dict1          # 浅拷贝: 引用对象
   dict3 = dict1.copy()   # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
    
   # 修改 data 数据
   dict1['user']='root'
   dict1['num'].remove(1)
    
   # 输出结果
   print(dict1)
   print(dict2)
   print(dict3)
   # result
   {'num': [2, 3], 'user': 'root'}
   {'num': [2, 3], 'user': 'root'}
   {'num': [2, 3], 'user': 'runoob'}
   #实例中 dict2 其实是 dict1 的引用（别名），所以输出结果都是一致的，dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改。
   

6. dict6.fromkeys(seq[, value])

   • 用于创建一个新字典(不对dict6进行修改)，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值

   • seq – 字典键值列表。

   • value – 可选参数, 设置键序列（seq）的值，默认为 None。

     seq = ('Google', 'Runoob', 'Taobao')
      
     # 不指定默认的键值，默认为 None 
     thisdict = dict.fromkeys(seq)
     print ("新字典为 : %s" %  str(thisdict))
      
     # 指定默认的键值
     thisdict = dict.fromkeys(seq, 10)
     print ("新字典为 : %s" %  str(thisdict))
     # result
     新字典为 : {'Google': None, 'Taobao': None, 'Runoob': None}
     新字典为 : {'Google': 10, 'Taobao': 10, 'Runoob': 10}
     

7. dict7.get(key,[,value])

   • key – 字典中要查找的键。

   • value – 可选，如果指定键的值不存在时，返回该默认值。

   • 返回指定键的值，如果键不在字典中返回默认值 None 或者设置的默认值。

   tinydict = {'Name': 'Runoob', 'Age': 27}
   
   print ("Age : %s" %  tinydict.get('Age'))
   
   # 没有设置 Sex，也没有设置默认的值，输出 None
   print ("Sex : %s" %  tinydict.get('Sex'))  
   
   # 没有设置 Salary，输出默认的值  0.0
   print ('Salary: %s' % tinydict.get('Salary', 0.0))
   # result
   Age : 27
   Sex : None
   Salary: 0.0
   

   • get()方法和dict[key]的区别

     get(key) 方法在 key（键）不在字典中时，可以返回默认值 None 或者设置的默认值。

     dict[key] 在 key（键）不在字典中时，会触发 KeyError 异常。

   • 对嵌套字典的使用

     tinydict = {'RUNOOB' : {'url' : 'www.runoob.com'}}
     
     res = tinydict.get('RUNOOB', {}).get('url')
     # 输出结果
     print("RUNOOB url 为 :  %s" % str(res))
     # result
     RUNOOB url 为 :  www.runoob.com
     

8. dict8.has_key(key)

   • 用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false

9. dict9.items()

   • 以列表返回可遍历的(键, 值) 元组数组。

   dict1 = {
       'a':1, 'b':2
   }
   print(dict1.items())
   # result
   dict_items([('a', 1), ('b', 2)])
   

10. dict10.keys()

    • 以列表返回一个字典所有的键。

    dict1 = {
        'a':1, 'b':2
    }
    print("%s" % dict1.keys())
    print("%s" % list(dict1.keys()))
    # result
    dict_keys(['a', 'b'])
    ['a', 'b']
    

11. dict11.setfault(key,default=None)

    • key – 查找的键值。

    • default – 键不存在时，设置的默认键值。

    • 如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值。

    dict1 = {
        'a':1, 'b':2
    }
    print(dict1.setdefault('s',"no"))
    print(dict1)
    # result
    no
    {'a': 1, 'b': 2, 's': 'no'}
    

12. dict12.update(tinydict)

    • 将字典tinydict更新到dict12中：

      如dict12中没有的，tinydit中有的，就直接将键值对添加到dict12中，如果tinydict中有的，dict12中也有，则将dict12中所对应的键的值改为tinydict中的值

      dict1 = {
          'a':1, 'b':2
      }
      dict2 = {
          'a':100, 'c':3
      }
      dict1.update(dict2)
      print(dict1)
      #result
      {'a': 100, 'b': 2, 'c': 3}
      

13. dict13.values()

    • 以列表返回字典中的所有值。

    tinydict = {'Name': 'Runoob', 'Age': 7}
    
    print ("Value : %s" %  tinydict.values())
    print ("Value : %s" % list(tinydict.values()) )
    # result
    Value : dict_values(['Runoob', 7])
    Value : ['Runoob', 7]
    

14. dict14.pop(key,[,default])

    • 删除字典给定键 key 所对应的值，返回值为被删除的值。

    • key - 要删除的键

    • default - 当键 key 不存在时返回的值

    • 返回被删除的值：

      • 如果 key 存在 - 删除字典中对应的元素
      • 如果 key 不存在 - 返回设置指定的默认值 default
      • 如果 key 不存在且默认值 default 没有指定 - 触发 KeyError 异常

      site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
      
      element = site.pop('name')
      
      print('删除的元素为:')
      print(element)
      print('字典为:')
      print(site)
      # result
      删除的元素为:
      菜鸟教程
      字典为:
      {'url': 'www.runoob.com', 'alexa': 10000}
      

15. dict15.popitem()

    • 返回并删除字典中的最后一对键和值。

    • 如果字典已经为空，却调用了此方法，就报出 KeyError 异常。

    site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
    pop_obj=site.popitem()
    print(pop_obj)
    print(site)
    # result
    ('url', 'www.runoob.com')
    {'name': '菜鸟教程', 'alexa': 10000}
    

逻辑运算

• 逻辑运算符是python用来进行逻辑判断的运算符，虽然运算符只有and、or、not三种，但是理解这三个运算符的原理才是最重要的

• python中对false的认定

  逻辑运算符是python用来进行逻辑判断的运算符，虽然运算符只有and、or、not三种，但是理解这三个运算符的原理才是最重要的

• and运算符

  • 两边都是表达式的情况：

    例子：print(30>20 and 40>30),运行结果为TRUE

    print(30>20 and 4>30),运行结果为FALSE

  • 一边是变量，另一边是表达式的情况 :

    **例子：**print(20 and (c:=30)>20)，运行结果是TRUE

    print(20 and (d:=20)>30)，运行结果为FALSE

  • 两边都是变量的情况 :

    例子：a=20,b=30,那么print(a and b) 运行结果为 30

    a=20,b=30,那么print(b and a) 运行结果为 20

    这个情况其实是最难以理解的，顺着下面的思路来。

    首先，and运算符的左边是a，这是个变量而不是表达式，所以无需判断左边一定是TRUE，而右边情况也是一样的，那么以为着两边的运算结果都是TRUE。

    而python当中对于这种情况是有定义的，当and 从左到右，若所有值均为真，则返回后一个值，只要有一个假的值，则返回第一个假的值。

• or运算符

  • 两边都是表达式的情况：

    例子：print(30>20 or 40>30),运行结果为TRUE

    print(30>20 or 4>30),运行结果为TRUE

    print(3>20 or 4>30),运行结果为FALSE

  • 一边是变量，另一边是表达式的情况：

    例子：print(20 or (c:=30)>20)，运行结果是20

    print(20 or (d:=20)>30)，运行结果为20

  • 两边都是变量的情况：

    例子：print(20 or 30)，运行结果是20

    print(30 or 20)，运行结果为30

    当or从左到右，若所有值均为假，则返回后一个值，只要有一个真的值，则返回第一个真的值

    print(0 or {})
    # result
    {}
    

  • not运算符

    例子：print(not(20>10))，运行结果为FALSE

    print(not(10>20)),运行结果为TRUE

pycharm快捷键介绍

• $CTRL + D $复制粘贴当行代码

函数介绍

split()函数

用法 : str.split(str=“”,num=string.count(str))[n]

$str$:表示为分隔符，默认为空格，但是不能为空(’’)。若字符串中没有分隔符，则把整个字符串作为列表的一个元素
$num$ :表示分割次数。如果存在参数num，则仅分隔成 $num+1 $个子字符串，并且每一个子字符串可以赋给新的变量

$[n]$:表示选取第$n$个分片

string = “www.gziscas.com.cn”

1.以’.'为分隔符

print(string.split(’.’))

[‘www’, ‘gziscas’, ‘com’, ‘cn’]

2.分割两次

print(string.split(’.’，2))

[‘www’, ‘gziscas’, ‘com.cn’]

3.分割两次，并取序列为1的项

print(string.split(’.’,2)[1])

gziscas

list()函数：

list()函数是Python的内置函数。它可以将任何可迭代数据转换为列表类型，并返回转换后的列表。当参数为空时，list函数可以创建一个空列表。

print()函数

a = 1
b = 2
sum = a + b
print( f"{a} + {b} = {sum}")
print("{0} + {1} = {2} ".format(a,b,sum))
print("%d + %d = %d"%(a,b,sum))

int(x,base=10)

$x$代表的是字符串或数字，base代表的进制数，默认十进制。将字符串（base进制下的）转化成数字（十进制下的）

输入的字符串如果是‘123’，就是代表123，输入的必须是数字。否则会报错

strip()，lstrip(),rstrip()

• 作用：

  去除输入字符串开头和结尾的空格或换行符等空白字符， 默认情况下去除空格、制表符、换行符等。 它确保输入的每行字符串在进行split()操作之前被去除了两端的空白字符，以避免不必要的错误或异常情况

依次是

• 去除字符串开头或者结尾的空白符
• 去除字符串开头的空格的空白符
• 去除字符串结尾的空格的空白符

使用方法

str1.strip()
str2.lstrip()
str3.rstrip()

replace()

可以去除可以去除全部空格，replace主要用于字符串的替换replace(old, new, count)

old是需要替换的值，new是替换后的值，max是最多替换的次数

str = "我把你当亲兄弟对待，而你却像对待爸爸一样对待我？这是为什么？？？？？";
print( str.replace("爸爸", "爷爷"))
print(str.replace("？", "：", 3))
#result
我把你当亲兄弟对待，而你却像对待爷爷一样对待我？这是为什么？？？？？
我把你当亲兄弟对待，而你却像对待爸爸一样对待我：这是为什么：：？？？

join()

用法：

‘sep’.join(seq)

参数说明
sep：分隔符。可以为空
seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串

返回值：返回一个以分隔符sep连接各个元素后生成的字符串

str = "I am your father"
print(':'.join(str))
# result
I: :a:m: :y:o:u:r: :f:a:t:h:e:r

map()

用法：

map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

>>> def square(x) :         # 计算平方数
...     return x ** 2
... 
>>> map(square, [1,2,3,4,5])    # 计算列表各个元素的平方
<map object at 0x100d3d550>     # 返回迭代器
>>> list(map(square, [1,2,3,4,5]))   # 使用 list() 转换为列表
[1, 4, 9, 16, 25]
>>> list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))   # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]

用法介绍

print（a）和print（*a）的区别

a = [1,2,3,4,4,5]
print(*a, sep=' ')
print(a,sep=' ')
# 运行结果
1 2 3 4 4 5
[1, 2, 3, 4, 4, 5]

dict[keys,values]和dict(zip(keys,values))的区别

keys= ['a','b']
values = [1,2]
print(dict([keys,values]))
print(dict(zip(keys,values)))
# 运行结果
{'a': 'b', 1: 2}
{'a': 1, 'b': 2}

如果在前面加一个*
如：print(*dict(zip(keys,values)))会怎么样?
# 运行结果
a b

格式化输出

python的格式化输出主要有四种方式：

• f-string

name = input()
print(f'I am {name} and I am studying Python in Nowcoder!')

• format()

name = input()
print('I am {} and I am studying Python in Nowcoder!'.format(name))

• %格式化

name = input()
print('I am %s and I am studying Python in Nowcoder!'%name)

• 普通法

print("I am",input(),"and I am studying Python in Nowcoder!")

注意

name = input()只能读入一个数据，数字，字符串等，不能是多个。

而输入name =input("").split(" ")(注意split（“”）中的“”中间无内容会报错，空格算内容)，这样的输入可以输入一个多个数字，字符串，都会放在列表中。但是如果是:

name1,name2 = input("请输入").split(" ")

此时就不能随意输入多个数据，必须是和前面变量对应数量的个数，否则也会报错。

注意事项

1. input().split("\n")无法实现隔行读取

2. 在Python中，字符串是不可变的，也就是你不能直接修改字符串中的某个字符。当你尝试执行 str1[0] = str((int(str1[0]) + 3) % 9) 这行代码时，Python会抛出一个错误，提示你不能为字符串的指定位置赋值。

   如果你想修改字符串中的某个字符，可以考虑将字符串转换为列表，进行修改后再转换回字符串。例如：

   str1 = list(str1)
   str1[0] = str((int(str1[0]) + 3) % 9)
   str1 = ''.join(str1)
   

   这样就可以实现将字符串中的第一个字符修改为 (int(str1[0]) + 3) % 9 的结果。

3. 为什么下面这段代码不能执行对list1的修改？

   str1 = input()
   list1 = list(str1)
   for i in range(len(list1)):
    list1[i] = str((int(list1[i]) + 3) % 9)
   
   print(list1)
   

   答：

   这段代码没有改变列表 list1 中的元素，是因为在循环中你使用的是变量 i ，它仅仅是一个迭代器，赋值操作并不会修改列表元素本身。每次迭代，i 都指向列表中的一个元素，但是对 i 的修改并不会反映到列表中。

   如果你想要修改列表中的元素，可以通过索引直接访问和修改元素。以下是修正后的代码：

   str1 = input()
   list1 = list(str1)
   for i in range(len(list1)):
    list1[i] = str((int(list1[i]) + 3) % 9)
   
   print(list1)
   

4. index和find函数的区别：

   • index用于列表和字符串，find用于字符串
   • index找不到会报错，find则会返回-1

5. 下标索引不会越界，但是下标使用会越界(列表，元组，字符串，字典)

   list1 =[ 1,3,4,5,5]
   print(list1[1:100000])
   # result
   [3, 4, 5, 5]
   

   list1 =[ 1,3,4,5,5]
   print(list1[8])
   # result
   list index out of range
   

   对于字典一样，如果查找的键不在字典中，就会报错

   所以防止报错，一般在字典中查找一个不确定在不在字典中的键时，我们使用in先检测是否在字典中

   name in dict1 and  secret == dict1[name]
   

保留小数

主要有三种方法

• print("{:.2f}".format(2.12312321))
  

• float1 = float(input(""))
  print("%.2f"%float1)
  

• a = 3.75
  
  print(round(a))
  
  >>> 4
  
  b = 3.25
  
  print(round(b))
  
  >>> 3
  
  c = 2.85
  
  print(round(c,1))  # 保留一位小数
  
  >>> 2.9
  

float转int

float转成int只需要int（）函数即可。

但是在输入字符串数，可能有人会想能不能直接通过int（）转换，如将字符”12.3“直接转成12:

value1 = int(input())

答案是不行的，字符串"123.123"不能通过int（）直接转换成123

正确做法是：

value1 = int(float(input()))

16进制转10进制

16进制转10进制，使用int()函数即可。

print(int(input(),base=16))

字母大小写转换

主要有两种方法：

1. 逐个遍历

python没有所谓的字符这个概念，所以更不可能存在c++中的A =‘\32’。如果要将要取出字符，要不然用下标索引，要不然直接用for in语句。

• order()函数实现将“字符”转成数字的操作
• chr()函数实现将数字转成“字符”的操作

msg = 'Niu Ke le'
for num in msg:
    if 97 <= ord(num) <= 122: #小写字母
        upper_num = ord(num)-32 #大小写字母之前差了32
        #chr()函数可以将编码数值转为字符（python没有字符的概念）
        print (chr(upper_num),end='')
    else:
        print(num,end='')  #不是小写字符，原样输出
print() #输出一个换行符
msg = 'Niu Ke le'
for num in msg:
    if 65 <= ord(num) <= 90: #大写字母
        upper_num = ord(num)+32 #大小写字母之前差了32
        #chr()函数可以将编码数值转为字符（python没有字符的概念）
        print (chr(upper_num),end='')
    else:
        print(num,end='')  #不是大写字符，原样输出
# result
NIU KE LE
niu ke le

2. 直接使用现有函数

.lower() --- 全部小写
.upper() --- 全部大写
.title() --- 各个字符的首字母大写
.capitalize() --- 首字母大写

*和**的用法

• 最常用的就是表示相乘。在数字和数字之间的运算中出现

• 表示倍数。就是字符串和数字之间的运算如

print("hi"*3)
# result
hihihi

• 在函数声明中，（p）代表是用来接受任意多个参数并将其放在一个元组中。

def func(*p):
 print(p)

func (1,2,3,4,4)
# result
(1, 2, 3, 4, 4)

2. **

• 最常用的就是表示取幂。在数字和数字之间运算

• 在函数声明中，（**p）又来接受任意多个参数并将其放在一个字典中。

  def func(**p):
   print(p)
  
  func(a=1,b=2,c=3) #这里的字典键不能是数字
  # result
  {'a': 1, 'b': 2, 'c': 3}
  

下标索引的用法

$strname[start:end:step]$

对各个部分的说明：

• strname：要截取的字符串；
• start：表示要截取的第一个字符所在的索引（截取时包含该字符）。如果不指定，默认为 0，也就是从字符串的开头截取；
• end：表示要截取的最后一个字符所在的索引（截取时不包含该字符）。如果不指定，默认为字符串的长度；
• step：指的是从 start 索引处的字符开始，每 step 个距离获取一个字符，直至 end 索引出的字符。step 默认值为 1，当省略该值时，最后一个冒号也可以省略。

值得一提的是，下标索引不会越界：

a = '123'
b = a[:5]
print(b)
# result
123

如何实现多行输入

• 行数不确定，每行多少个个数确定：

  while True:
   try:
       a ,b ,c = map(int,input().strip().split())
       print(a,b,c)
   except EOFError:
       break
  print("end")
  

• 行数不确定，每行多少个也不确定：

  while True:
   try:
       list1 =list(map(int,input().strip().split()))
       print(list1)
   except EOFError:
       break
  print("end")
  

如何解决index找不到元素时报错

• 多加一个in语句事先判断是否在列表中，若有再使用index，否则就输出False。

list1 = input().strip().split()
name = input()

if ( name in list1):
    print(list1.index(name))
else:
    print(False)

如何快速打印列表中的所有元素

• 打印列表中的所有元素，可能大家都会想这不就直接一个for循环就OK的吗？其实还有更加优雅的方法

  print(' '.join(list1))
  

如何判断列表是否为空

if ( list1 ):

if (len(list1) == 0)

if-else的特殊用法

• 表达式1 if 表达式2 else 表达式3

  如果表达式为真则执行表达式1，否则执行表达式2。

  例子：

  my_list = [] # 第二行和第三行其实是同一行，在这里太窄了
  print('my_list is empty!') if not my_list else print('my_list is not empty!')
  

对于二维列表的列表解析

如果存在一个矩阵$x$，让你求解$3x$的值，你要怎么做?

---

矩阵如图所示，输入一个n，求解$nx$，打印出该列表。

$$\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\\ 7& 8& 9\end{array}$$

• 首先我们要存储这个矩阵，通过列表方式存储，当然没有必要可以创建二维列表。python中列表可以存列表

  list1 = [1,2,3]
  list2 = [4,5,6]
  list3 = [7,8,9]
  matrix_list = [list1,list2,list3]
  

• 然后就是通过帅气的列表解析来一步到位（不会还有人用双重for循环吧）

  n = int(input())
  matrix_list = [[j*n for j in i]for i in matrix_list]
  print(matrix_list)
  

python中输入转列表/元组

• 由于input()通过split切割后就会放在列表中,所以可以不用list()

  tup1 = tuple(input().strip().split())
  list1 = list(input().strip().split())
  list2 = input().strip().split()
  

元组能不能使用列表解析

• 很遗憾,元组不能使用列表推导式

  • 如在列表中我们可以如下生成一个列表:

  list1 =[i for i in range(0,6) if i %2 == 0]
  print(list1)
  # result
  [0, 2, 4]
  

  • 但是在元组中就不太行了:

    tup1 = (i for i in range(1,3) if i %2 == 0)
    print(tup1)
    # result
    <generator object <genexpr> at 0x0000021917700580>
    

  • 但是我们可以这样子:

    tup1 = tuple(i for i in range(1,3) if i %2 == 0)
    print(tup1)
    # result
    (2,)
    

zip()和fromkeys()

在Python中，zip()和fromkeys()是两个不同的内置函数，它们具有不同的功能和用途。

1. zip()函数用于将多个可迭代对象（如列表、元组等）中对应位置的元素打包成一个新的元组，返回一个迭代器。每个元组的元素来自于不同的可迭代对象在相同位置的元素。
   例如：

   list1 = [1, 2, 3]
   list2 = ['a', 'b', 'c']
   result = zip(list1, list2)
   print(list(result))  # [(1, 'a'), (2, 'b'), (3, 'c')]
   

   zip()函数可以用于快速组合多个列表或元组的元素，通常与循环结构一起使用。

2. fromkeys()函数用于创建一个新的字典，其中指定的键被设置为同一个值（默认为None），返回这个新的字典。
   例如：

   keys = ['a', 'b', 'c']
   value = 0
   result = dict.fromkeys(keys, value)
   print(result)  # {'a': 0, 'b': 0, 'c': 0}
   

   fromkeys()函数可以用于快速创建包含特定键和默认值的字典。

总结：

• zip()函数用于打包多个可迭代对象，返回一个迭代器。
• fromkeys()函数用于创建一个新字典，其中的键为指定值，可以指定统一的值或使用默认值None。

它们的区别主要在于功能和用途。zip()用于组合多个可迭代对象的元素，而fromkeys()则用于创建新的字典。

什么时候可以使用list()转换成列表

在Python中，可以使用list()函数将可迭代对象转换为列表。可迭代对象是指可以被迭代遍历的对象，比如字符串、元组、集合、字典等。

list()函数可以接受不同类型的可迭代对象作为参数，并将其转换为列表。具体转换规则如下：

1. 如果可迭代对象是一个字符串，list()函数会将字符串中的每个字符作为列表的一个元素。

my_str = "Hello"
my_list = list(my_str)
print(my_list)

输出结果：

['H', 'e', 'l', 'l', 'o']

1. 如果可迭代对象是一个元组，list()函数会将元组的元素作为列表的元素。

my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)

输出结果：

[1, 2, 3]

1. 如果可迭代对象是一个集合，list()函数会将集合的元素作为列表的元素。由于集合无序且元素不可重复，生成的列表也无序且元素不重复。

my_set = {1, 2, 3}
my_list = list(my_set)
print(my_list)

输出结果：

[1, 2, 3]

1. 如果可迭代对象是一个字典，list()函数会将字典的键作为列表的元素。注意，字典的元素顺序是不确定的，因为字典是无序的数据结构。

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
my_list = list(my_dict)
print(my_list)

输出结果：

['name', 'age', 'city']

需要注意的是，list()函数并不递归地将可迭代对象中的所有元素都转换为列表。它只转换最外层的元素。如果你希望将嵌套的可迭代对象转换为列表，可以使用递归或其他方法来实现。

总结来说，当你需要将可迭代对象转换为列表时，可以使用list()函数来实现。这对于需要使用列表数据结构的场景非常有用。

什么时候可以使用dict()转换成字典

在Python中，可以使用dict()函数将可迭代对象转换为字典。可迭代对象是指可以被迭代遍历的对象，比如列表、元组、集合等。

dict()函数可以接受不同类型的可迭代对象作为参数，并根据不同的情况将其转换为字典。具体转换规则如下：

1. 如果可迭代对象是一个包含可哈希的键值对元组的列表，那么dict()函数会将其转换为字典。每个键值对元组中，第一个元素会被视为键，第二个元素会被视为对应的值。

my_list = [('name', 'John'), ('age', 30), ('city', 'New York')]
my_dict = dict(my_list)
print(my_dict)

输出结果：

{'name': 'John', 'age': 30, 'city': 'New York'}

1. 如果可迭代对象是一个包含可哈希的键值对元组的元组（或其他可迭代对象），那么dict()函数也会将其转换为字典。每个键值对元组中，第一个元素会被视为键，第二个元素会被视为对应的值。

my_tuple = (('name', 'John'), ('age', 30), ('city', 'New York'))
my_dict = dict(my_tuple)
print(my_dict)

输出结果同样为：

{'name': 'John', 'age': 30, 'city': 'New York'}

1. 如果可迭代对象是一个包含可哈希的键值对元组的集合，处理方式与列表类似。

my_set = {('name', 'John'), ('age', 30), ('city', 'New York')}
my_dict = dict(my_set)
print(my_dict)

输出结果同样为：

{'name': 'John', 'age': 30, 'city': 'New York'}

需要注意的是，在转换过程中，dict()函数会自动忽略重复的键值对。只有最后一个具有相同键的键值对将保留在生成的字典中。

当你需要将可迭代对象转换为字典时，可以使用dict()函数来实现这个转换。这在处理需要使用字典数据结构的数据时非常有用。

需要熟悉的代码

• 字典

  • 字典是python中独一无二的东西，有些代码需要多去感受

  dict1 = {'<': 'less than','==': 'equal'}
  print('Here is the original dict:')
  for x in sorted(dict1):
   print(f"Operator {x} means {dict1[x]}.")
  print("")
  dict1['>'] = 'greater than'
  print("The dict was changed to:")
  for x in sorted(dict1):
  print(f'Operator {x} means {dict1[x]}.')
  

  dict1 = {'name': 'Niuniu','Student ID': 1}
  dict2 = {'name': 'Niumei','Student ID': 2}
  dict3 = {'name': 'Niu Ke Le','Student ID': 3}
  list1 = []
  list1.append(dict1)
  list1.append(dict2)
  list1.append(dict3)
  
  for i in list1:
      print(f"{i['name']}'s student id is {i['Student ID']}.")
  

  dict1 ={'Beijing': {'Capital': 'China'},'Moscow': {'Capital': 'Russia'},'Paris': {'Capital': 'France'}}
  
  for i in sorted(dict1):
      print(f"{i} is the capital of {dict1[i]['Capital']}!")