挑战一天速通python基础语法

挑战一天速通python基础语法

再有一个月参加一个NTU的线上科研项目。。完全陌生的领域，所以咱来速通一下，不至于到时候过于狼狈。。仅做个人学习留念，不具任何参考价值

笑死，一打开pycharm还是上学期折磨我的填空实验，根本什么都看不懂，okay???

0. 防止某人健忘

设置字体

shift+F6可以统一更改变量名。

1. 一些小点

注释

# 我好想你呀，就像想上厕所，到家门口一样

文档注释'''也可

"""
 我好想你呀，就像想上厕所，到家门口一样
"""

一些算术运算符

• ** 是求乘方. 不光能算整数次方, 还能算小数次方

• // 是取整除法(也叫地板除). 整数除以整数, 结果还是整数(舍弃小数部分, 并向下取整. 不是四舍五入)

  

一些关系运算符

• 返回值为布尔类型True/False

• 关系运算符不光针对整数/浮点数进行比较, 还能针对字符串进行比较

  • 直接使用 == 或者 != 直接对字符串内容判定相等. (这一点和 C / Java 是不行的，否则比较的是字符串首元素地址/是否同一对象).
  • 字符串比较大小, 规则是 “字典序”。中文按字典序是没意义的，中文实际上是多个字节构成的比较大的数字进行比较的
  • 对于浮点数来说, 不要使用 == 判定相等.。这是因为浮点数在计算机中的表示并不是精确的! 在计算过程中, 就容易出现非常小的误差.

一些逻辑运算

and/or/not

• a < b and b < c 这个操作等价于 a < b < c . 这个设定和大部分编程语言都不相同.

一些赋值运算符

多元赋值

a, b = 10, 20

基于多元赋值的变量交换，有意思

a = 19
b = 20
a,b = b,a

像 C++ / Java 中, 存在 ++/ -- 这样的自增/自减运算符. Python 中则不支持这种运算. 如果需要使用, 则直接使用 += 1 或者 -= 1

++ – 最大的问题就是容易分不清前置和后置的区别. 这一点 Python 语法在设计的时候就进行了规避, 避免出现这种不直观, 并且容易混淆的语法.

其他

除了上述之外, Python 中还有一些运算符, 比如 身份运算符 (is, is not), 成员运算符 (in, not in), 位运算符( & | ~ ^ << >>) 等.

暂时不做介绍啦~~

2. 输入输出

2.1 输出

输出的内容是混合了字符串和变量的

a = 10
print(f'a = {a}')

• 使用 f 作为前缀的字符串, 称为 f-string —— 格式化字符串format,python3.6后才开始支持

• 里面可以使用{ }来内嵌一个具体的变量/表达式

  

  Python 中还支持其他的格式化字符串的方法, 咱们此处只了解这个最简单的即可. 其他的暂时不做介绍.

2.2 输入

num = 0
num = input('你小子最好给我明白着点~')
print(f'num = {num}')

• input 的参数相当于一个 “提示信息”, 也可以没有.

• input 的返回值就是用户输入的内容. 是字符串类型. 因此，如果要用用户输入的内容进行算术运算，则需要先强转int()/str()等等

3. 一些基础语法

3.1 条件语句

1. if

   if expression:
    do_something1
    do_something2
   next_something #if代码块之外的内容
   

   if / else 命中条件后要执行的 “语句块”, 使用 缩进 (通常是 4 个空格或者 1 个 tab) 来表示

2. if - elif - else

   if expression1:
    do_something1
   elif expression2:
    do_something2
   else:
    do_something
   

3. if -else

   if expression:
    do_something1
   else:
    do_something2
   

3.2 循环语句

1. while

   while 条件:
       循环体
   

2. for

   • python 的 for 和其他语言不同, 没有 “初始化语句”, “循环条件判定语句”, “循环变量更新语句”, 而是更加简单
   • 所谓的 “可迭代对象”, 是一个特殊的变量，指的是 “内部包含多个元素, 能一个一个把元素取出来的特殊变量”

   打印1-10 ——

   for i in range(1, 11):
       print(i)
   

   • 使用 range 函数, 能够生成一个可迭代对象. 生成的范围是 [1, 11), 也就是 [1, 10]

   打印2,4,6,8,10 ——

   for i in range(2, 12, 2):
       print(i)
   

   • 通过 range 的第三个参数, 可以指定迭代时候的 “步长”. 也就是一次让循环变量加几. 默认是1

   • range 的 步长 也可以设定成负数

3. continue 和 break

   • continue 结束本次循环
   • break 结束全部循环

3.3 空语句

python对于代码的缩进要求比较高，如果啥也不写/只写注释，是不符合语法要求的 ——

a = int(input("请输入一个整数:"))
if a != 1:
    
else:
	print("hello")

想起来verilog也是，啥也不写时候必须写begin-end

pass 表示 空语句, 并不会对程序的执行有任何影响, 只是占个位置, 保持 Python 语法格式符合要求

a = int(input("请输入一个整数:"))
if a != 1:
 	pass
else:
    print("hello")

4. 函数

def 函数名(形参列表):
    函数体
    return 返回值

函数名(实参列表)           # 不考虑返回值
返回值 = 函数名(实参列表)   # 考虑返回值

• 和 C++ / Java 不同, Python 是动态类型的编程语言, 函数的形参不必指定参数类型. 换句话说, 一个函数可以支持多种不同类型的参数,代替了函数重载

• Python 中的函数, 可以给形参指定默认值. 带有默认值的参数, 可以在调用的时候不传参，其他注意事项同C++

• 一个函数是可以一次返回多个返回值的，使用,来分割多个返回值.

  def getPoint():
      x = 10
      y = 20
      return x, y
  a, b = getPoint()
  

• 如果只想关注其中的部分返回值, 可以使用 _ 来忽略不想要的返回值.

  def getPoint():
      x = 10
      y = 20
      return x, y
  _, b = getPoint()
  

关于变量的作用域

如果是想在函数内部, 修改全局变量的值, 需要使用 global 关键字声明

x = 20

def test():
    global x
    x = 10
    print(f'函数内部 x = {x}')
    
test()
print(f'函数外部 x = {x}')

如果此处没有 global , 则函数内部的 x = 10 就会被视为是创建一个局部变量 x, 这样就和全局变量 x 不相关了.

if / while / for 等语句块不会影响到变量作用域，也就是说，这只和函数语句块相关。

关键字形参

我们也可以通过 关键字参数, 来调整这里的传参顺序, 显式指定当前实参传递给哪个形参.

def test(x, y):
    print(f'x = {x}')
    print(f'y = {y}')
test(x=10, y=20)
test(y=100, x=200)

5. 列表和元组

这俩玩意就相当于数组

元组和列表相比, 是非常相似的, 只是列表中放哪些元素可以修改调整, 元组中放的元素是创建元组的时候就设定好的, 不能修改调整**.**

5.1 列表

创建列表主要有两种方式. [] 表示一个空的列表

alist = [ ]	   # 比较推荐这个，因为看起来简单
alist = list() # list内建函数

• 可以在[]中指定列表的初值

• 可以直接使用 print 来打印 list 中的元素内容

• 列表中存放的元素允许是不同的类型 (这一点和 C++ Java 差别较大).

• len 函数可以获取到列表的元素个数.

访问列表

可以通过下标访问操作符 [ ] 来获取到列表中的任意元素.

• 可读可写

• 下标可以取负数. 表示 “倒数第几个元素”

  

列表切片

通过切片, 则是一次取出一组连续的元素, 相当于得到一个 子列表

• 使用 [a:b] 的方式进行切片操作，左闭右开

• 切片操作中可以省略前后边界

• 切片操作还可以指定 “步长” , 也就是 “每访问一个元素后, 下标自增几步”

  alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  print(alist[::1])
  print(alist[::2])
  

• 切片操作指定的步长还可以是负数, 此时是从后往前进行取元素. 表示 “每访问一个元素之后, 下标自减几步”

• 如果切片中填写的数字越界了, 不会抛异常. 只会尽可能的把满足条件的元素过去到.

遍历链表

• for 循环

alist = [1, 2, 3, 4]
for elem in alist:
    print(elem)

增删查

增

alist = [1, 2, 3, 4]
alist.append('hello')
print(alist)

alist.insert(1, 'hello')
print(alist)

删

alist = [1, 2, 3, 4]
alist.pop()
print(alist)

alist.pop(2) #按照下标
print(alist)

alist.remove(2) #按照值
print(alist)

查

• 使用in操作符, 判定元素是否在列表中存在. 返回值是布尔类型.
• 使用index方法, 查找元素在列表中的下标. 返回值是一个整数. 如果元素不存在, 则会抛出异常.

alist = [1, 2, 3, 4]
print(2 in alist)
print(10 in alist)

print(alist.index(2))
print(alist.index(10))

列表的连接

• 使用 + 能够把两个列表拼接在一起. 此处的 + 结果会生成一个新的列表. 而不会影响到旧列表的内容.

• 使用 extend 方法, 相当于把一个列表拼接到另一个列表的后面. +=效果和它相同

  alist.extend(blist)
  

它的优势有以下两方面：

• 你有一个列表, 现在需要调用一个函数进行一些处理. 但是你有不是特别确认这个函数是否会把你的列表数据弄乱. 那么这时候传一个元组就安全很多
• 我们马上要讲的字典, 是一个键值对结构. 要求字典的键必须是 “可hash对象” (字典本质上也是一个hash表). 而一个可hash对象的前提就是不可变. 因此元组可以作为字典的键, 但是列表不行.

5.2 元组

元组的功能和列表相比, 基本是一致的.

atuple = ( )
atuple = tuple()

元组不能修改里面的元素, 列表则可以修改里面的元素，因此

• 读操作,比如访问下标, 切片, 遍历, in, index, + 等, 元组也是一样支持的.
• 写操作, 比如修改元素, 新增元素, 删除元素, extend 等, 元组则不能支持.

当一个函数返回多个值的时候. 返回值类型就是

6. 字典

字典是一种存储 键值对 的结构.

字典创建

a = { }
b = dict()

• 键值对之间使用 , 分割，键和值之间使用 : 分割. (冒号后面推荐加一个空格).
• 使用 print 来打印字典内容

为了代码更规范美观, 在创建字典的时候往往会把多个键值对, 分成多行来书写.

student = {
    'id': 1,
    'name': 'zhangsan'
}

• 最后一个键值对, 后面可以写 , 也可以不写.

查找key

• 使用 in (notin)可以判定 key 是否在 字典 中(不)存在. 返回布尔值. 不能用于查找 value

  student = {
      'id': 1,
      'name': 'zhangsan',
  }
  print('id' in student)
  

• 使用 [ ] 通过类似于取下标的方式, 获取value. 只不过此处的 “下标” 是 key. (可能是整数, 也可能是字符串等其他类型).；如果 key 在字典中不存在, 则会抛出异常.

  student = {
      'id': 1,
      'name': 'zhangsan',
  }
  print(student['id'])
  

对于字典，in/[]获取value是比较高效的，因为用了特殊的数据结构“哈希表”，但是对列表来说，需要遍历所以是较为低效的。

新增/修改元素

使用 [ ] 可以根据 key 来新增/修改 value

• 如果 key 已经存在, 对取下标操作赋值, 即为修改键值对的值.
• 如果 key 不存在, 对取下标操作赋值, 即为新增键值对

删除元素

使用 pop 方法根据 key 删除对应的键值对.

student.pop('score')

遍历字典元素

student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}
for key in student:
    print(key, student[key])

字典并非单纯的哈希表

取出所有的key和value

• 使用 keys 方法可以获取到字典中的所有的 key

print(student.keys()) 

此处 dict_keys 是一个特殊的类型, 专门用来表示字典的所有 key. 大部分元组支持的操作对于dict_keys 同样适用.

• 使用 values 方法可以获取到字典中的所有 value

print(student.values())

此处 dict_values 也是一个特殊的类型, 和 dict_keys 类似.

• 使用 items方法可以获取到字典中所有的键值对.

print(student.items())

此处 dict_items 也是一个特殊的类型, 和 dict_keys 类似.

合法的 key 类型

字典本质上是一个 哈希表, 哈希表的 key 要求是 “可哈希的”, 也就是可以计算出一个哈希值.

可以使用 hash 函数计算某个对象的哈希值，比如：

print(hash(0)) 			#整数
print(hash(3.14)) 		#浮点数
print(hash('hello')) 	#字符串
print(hash(True)) 		#布尔值
print(hash(()))   		#元组

列表/字典无法计算哈希值

7. 文件操作

1. 打开文件

   使用内建函数 open 打开一个文件

   • 第一个参数是一个字符串, 表示要打开的文件路径
   • 第二个参数是一个字符串, 表示打开方式. 其中r表示按照读方式打开. w 表示按照写方式(清空原有内容)打开. a表示追加写方式打开.

   f = open('d:/test.txt', 'r')
   

   • 如果打开文件成功, 返回一个文件对象. 后续的读写文件操作都是围绕这个文件对象展开.

   • 如果打开文件失败(比如路径指定的文件不存在), 就会抛出异常.

   • 显式的指定为和文本相同的字符集

     f = open('d:/test.txt', 'r', encoding='utf8')
     

2. 写文件

   f = open('d:/test.txt', 'w')
   f.write('hello')
   f.close()
   

3. 读文件

   • 使用 read 方法完成读操作. 参数表示 “读取几个字符”

   f = open('d:/test.txt', 'r')
   result = f.read(2)
   print(result)
   f.close()
   

   • 如果文件是多行文本, 可以使用 for 循环一次读取一行.

   f = open('d:/test.txt', 'r')
   for line in f:
       print(f'line = {line}', end='') #手动去掉换行
   f.close()
   

   • 使用 readlines 直接把文件整个内容读取出来, 返回一个列表. 每个元素即为一行.

   f = open('d:/test.txt', 'r')
   lines = f.readlines()
   print(lines)
   f.close()
   

4. 关闭文件

   f.close()
   

5. 使用上下文管理器

   打开文件之后, 是容易忘记关闭的. Python 提供了 上下文管理器 , 来帮助程序猿自动关闭文件

   with open('d:/test.txt', 'r', encoding='utf8') as f:
       lines = f.readlines()
       print(lines)