[Python知识库]【Python】从0开始学Python-必备基础知识

变量和赋值

• Python中的变量不需要声明, 直接定义即可, 会在初始化的时候决定变量的 “类型”

count = 0		#int
mile =1000.0	#python不区分单精度和双精度,float->双精度
name = "Mango"	#字符串类型

• 使用 = 来进行初始化和赋值操作.
• Python中也支持增量赋值

n = n*10   # 等价于 n *=10

• Python中不支持 ++/-- 这样的操作, 只能写成+= -=

num++ #报错
++num #不报错,被当成了两个正号
#应该写成:
n += 1

动态类型

python是一个动态类型语言, 即:一个变量在运行过程中,类型可以发生变化

• 同一个变量, 可以赋值成不同的类型的值.

a = 100
print(a) 	#100
a = 'Mango'
print(a) 	#Mango

变量命名规则

• 变量名必须是字母, 数字, 下划线. 但是不能用数字开头(规则和C语言一样).
• 变量名大小写敏感, case 和 Case 是两个不同的变量.
• 变量命名要做到 “见名知意”

数字

Python没有int, float, 这样的关键字, 但是实际上数字的类型是区分 “int” “float” 这样的类型的. 使用内建函数 type 可以查看变量的类型.

内建函数:type()

a=1
print(type(a))  #<class 'int'>
a = 1.0
print(type(a))  #<class 'float'>

• Python中的数字变量的取值范围, 并没有限制(完全取决于你机器的内存多大), 而不是像C语言中int用4个字节表示. 所以可以 使用python计算大数

a = 1000 * 1000 * 1000 * 1000 * 1000 * 1000
print(a)	#1000000000000000000

复数

Python中还有一种 “复数” 类型. 和数学中的 “复数” 是相同的概念.

a = 10+5j	#只能为j	
print(a)	#10+5j

字符串

如何表示

Python中可以使用 单引号(‘), 双引号("), 三引号(’‘’/“”") 来表示字符串

a = 'he'
b = "hehe"
c = '''hehe'''

好处:不需要转义

例子:字符串如果包含了"这样的字符

a = 'My name is "Mango" '
print(a)	#My name is "Mango" 

a = "My name is 'Mango' "
print(a)	#My name is 'Mango' 

• 如果一个字符串中既有单引号, 又有双引号, 可咋办?

使用三引号

a = '''My 'name' is "Mango" '''
print(a)	#My 'name' is "Mango" 

• 有些不可见字符, 仍然得进行转义, 使用 \ 进行转义. 比如换行符 \n

例子:

a = 'My name is \\n "Mango" '
print(a)	#My name is \n "Mango"

• \ 本身需要 \ 这样的方式来表示

关于索引(切片)

• 使用索引操作符 [] 或者切片操作符 [A:B] 来获取子字符串(切片操作是一个前闭后开区间 [A,B).
• 字符串的索引规则是: 第一个字符索引是0, 最后一个字符索引是-1 -1 == len(字符串)-1
  • 从前往后数:从0开始 从后往前数:从-1开始

str = 'hehe'
#切片
print(str[0]) 	#h
print(str[-1])	#e
print(str[1:3])	#eh		左闭右开区间
print(str[:3])	#heh
print(str[1:])	#ehe
print(str[:])	#hehe

print(str[100])	#error 越界

切片:

省略左侧数字:从0开始(含0下标字符)

省略右侧数字:到-1结束(含-1下标字符)

两侧都省略:从头到尾

字符串拼接

• 用于字符串连接运算, * 用于字符串重复 注意:只能*整数

a = 'hehe'
b = "haha"
c = a+b		#字符串拼接
print(c)	#hehehaha
print(a*3)	#hehehehehehe
print(a*3.0)	#error	只能*整数

• Python没有 “字符类型” 这样的概念. 单个字符也是字符串.

a = "hehe"
print(type(a[0]))	#<class 'str'>

len函数

• 用内建函数 len 获取字符串长度

a = "hehe"
print(len(a))	#4

格式化字符串

• 格式化字符串, 可以使用 % 这样的方式进行格式化的替换

不推荐写法1:

num = 100
a = 'num = %d' % num
print(a)	#num = 100


a = 100
print("a = %d " %a)	#a = 100

不太推荐

num = 100
a = 'num = {}'.format(num)	#写法含义:把num的值替换到{}里面
print(a)	#num = 100

推荐写法:python3.6以上才支持

加前缀f

num = 10
a = f'num = {num}'	#直接把num替换进去
print(a)	#num = 10

布尔类型

作为一个程序猿, 只要知道布尔值表示的是一个表达式的的 “真” 和 “假” 就行了

• Python中用True和False来表示布尔值(注意, 第一个字符大写).

a = True
# a = true    #error 首字母大写
print(a)	#True
print(type(a))	#<class 'bool'>

• 布尔类型的变量, 也是一种特殊的整数类型. 在和整数进行运算时, True被当做1, False被当做0.

a = True
b = False
c =0
print(a+c)	#1
print(b+c)	#0

输入输出

• print函数将结果输出到标准输出(显示器)上.

  • print打印完默认会换行

  • 如果不想换行:多加一个参数

    a = 'name'
    print(a,end = ' ')	#以空字符作为分割
    

• input函数从标准输入中获取用户输入

  name = input("请输入名字:")	#可以附带输入提示
  print(name)
  #执行结果:
  请输入名字:Mango
  Mango
  

input返回的结果只是一个字符串. 如果需要获得一个数字, 需要使用eval函数把字符串转换成对应的指令

a = input()
# print(a +1)     #error input返回的是字符串,不能把字符串和整数相加
print(eval(a) + 1)

注释

Python中使用 # 作为单行注释. #后面的内容都是注释的内容

• 良好的注释, 也是一个优秀的程序猿必备的技能之一.

• 使用中文注释时, 要小心 直接使用可能会运行报错(Python3 目前已经没有这个问题了, Python2要注
  意).

• Python的源代码默认只支持ASCII, 所以如果要包含中文, 需要在代码文件最开头的地方注明

  • #coding: UTF-8 写在第一行
    

操作符

• Python中支持 + - * / % 这样的操作符. 并且它们的行为都和C语言一样.

• / 是 “精确除法”

  a = 1
  b = 2
  print(a/b)	#0.5
  

• // 是 “整除”. 会对结果进行取整

  • Python2 中 / 是传统除法(即1/2 = 0) // 是地板除法, 和 Python3 的语义截然不同.

  a = 1
  b = 2
  print(a//b)		#0
  

• ** 表示乘方运算(记得Python的数据无上限) a**b <==> a的b次方

  a = 100
  b = 10
  print(a**b)	#100000000000000000000
  

• Python也支持标准的比较运算符. > < >= <= == != 这些运算符的表达式的结果, 是一个布尔值

  a = 2 < 4
  print(type(a))	#<class 'bool'>
  

• Python也支持逻辑运算符. and or not(相当于 与 或 非 ) 注意:符合短路原则

  • 短路原则:

    and：左边为False 就不看右边

    or : 左边为True,就不看右边了

  a = 2<4 and 2 == 4
  print(a)	#False
  
  a = 2<4 or 2 == 4
  print(a)	#True
  

• Python中, 3 < 4 < 5 等价于 3 < 4 and 4 < 5 这一点和其他大多数编程语言都不太一样.

• 运算符之间有高低优先级的区分. 应该合理使用括号来增加代码的可读性.

• 字符串和字符串之间也可以使用运算符进行操作,

  • 例如前面使用 + 进行字符串连接

  print('hehe' + 'haha')	#hehehaha
  

• 字符串之间可以使用 == !=来判定字符串的内容是否相同

  print('hehe' != 'haha')	#True
  print('hehe' == 'haha')	#False
  

• 字符串之间也可以比较大小. 这个大小的结果取决于字符串的 “字典序”

  C,C++,Java都是按字典序进行比较字符串

  print('hehe' < 'haha')		#False
  print('mango' > 'Mango')	#True
  

列表,元组,字典

列表和元组

• 列表和元组类似于C语言中的数组.

• 使用 [] 来表示列表list, 使用 () 来表示元组tuple

  alist = [1,2,3,4]	#列表
  print(alist)	#[1, 2, 3, 4]
  print(len(alist))	#4
  print(alist[1:-1])	#[2,3]	左闭右开
  print(alist[1])		#2
  print(alist[-1])	#4
  	
  atuple = (1,2,3,4)	#元组
  print(atuple)	#(1, 2, 3, 4)
  

• 列表和元组能保存任意数量, 任意类型的Python对象

  a = [1,'list']
  print(a)	#[1, 'list']
  

• 可以使用下标来访问里面的元素, 下标从0开始. 最后一个下标为-1

  a = [1,'list']
  print(a[0])	#1
  print(a[1])	#list
  print(a[1][2])	#s
  

• 可以使用[A:B]切片操作得到列表或元组的子集. 这个动作和字符串操作是一样的.注意:切片切出来的也是列表或元组

  a = [1,'list']
  print(a[:])	#[1, 'list']
  print(a[0:1])	#[1]
  

• 列表和元组唯一的区别是, 列表中的元素可以修改, 但是元组中的元素不能修改.

  • 本质区别:列表:可变对象 元组:不可变对象

  a = [1,2,3,4]
  a[0] = 100  #列表可变
  
  a = (1,2,3,4)
  a[0] = 100  #元组不可变 error
  

字典

• 字典是Python中的映射数据类型. 存储键值对(key-value).
• 几乎所有类型的Python对象都可以用作键. 不过一般还是数字和字符串最常用.
• 使用 {} 表示字典.

例子

键是怎么样,访问就怎么样.不同的键值对用逗号分割

键和值用:分割 键要用''括起来

a = {'ip':'127.0.0.1' , '1':'2'}  #字典
print(a['ip'])    #取字典中的元素	执行结果:127.0.0.1
a['port'] = 80  #插入新的键值对
print(a)	#{'ip': '127.0.0.1', 'port': 80}

引用

内建函数id

Python中可以用 id 这个内建函数, 查看变量的 “地址”

• 地址只是身份标识

a = 100	
print(id(a))	#140734889684720

a = 200	#给a重新赋值成200, 相当于新创建了一个200这样的对象, 然后将变量名a重新绑定到200这个对象上
print(id(a))	#140734889687920

b = a	#将a赋值给b, 其实相当于又创建了一个变量名b, 并将b这个名字和200这个对象绑定到一起.
print(id(b))	#140734889687920

b = 300	#
print(id(b))	#2642453910960

像创建 a, b 这样的变量名, 其实只是一个对象的别名. 或者叫做变量的 “引用”,这个变量真正在内存开辟空间,但是a和b并不开辟空间,a和b相当于贴在这个变量身上的标签

代码块及缩进

• Python中使用缩进来表示代码块. 相当于天然从语法的角度规定了代码风格.
• Python是独一无二的使用缩进而不是{}的, 这就避免了一场党派之争~

党派1:

if (a > b)
{
    do_something()
}

党派2

if (a > b){
    do_something()
}

python:并不存在大括号. 因此也就不需要考虑大括号放在哪里了.

if a > b:
    do_something()

if语句

如果表达式的值非0或者为布尔值True, 则执行 do_something, 否则执行下一跳语句.

注意:判断语句后面要加:

if expression:
	do_something1
    do_something2
next_something

• Python也支持else语句

  if expression:
  	do_something1
  else:
      do_something2
  

• Python里还有神奇的的elif(意思是else-if)

  if expression:
  	do_something1
  elif expression2:
      do_something2
  else:
      do_something3
  

• Python并不支持switch/case这样的语句. 也没有必要支持. 实际上 switch/case 语法并不优雅.

while语句

while循环语句和if语句语法类似. 只要表达式的值非0或者为True, 就会循环执行do_something

注意:判断语句后面要加:

while expection:
    do_something

例子:循环三次打印

count = 0
while count < 3:
    print('loop %d' %count)
    count+=1	#不可以用count++
#执行结果
loop 0
loop 1
loop 2

for循环

Python中的for循环和传统的for循环不太一样.

注意:判断语句后面要加:

• for循环接收可迭代对象(序列或者迭代器)作为参数, 每次迭代其中的一个元素.

#遍历打印字符串的每个字符
a = 'hehe'
for c in a:
    print(c)
#执行结果
h
e
h
e

#遍历列表的每个元素
a =[1,2,3,4]
for item in a:
    print(item)
#执行结果
1
2
3
4


#遍历字典中的所有key-value
a = {'ip':"198.168.1.1",'tel':'12345'}
for key in a:
    print(a[key])   #打印键对应的值
    print(key,a[key]) #打印键和值
#执行结果
198.168.1.1
ip 198.168.1.1
12345
tel 12345

关于内建函数:range函数

• 内建函数range能够生成一个数字组成的列表, 方便进行for循环遍历.

  • 区间:左闭右开,生成一个区间范围

  for i in range(0,3):
      print('loop %d' %i)
  #执行结果
  loop 0
  loop 1
  loop 2
  

• range函数其实有三个参数.

  • **前两个参数分别表示了一个前闭后开的区间. **
  • 第三个参数表示step, 每次迭代的步长

  如果只写一个参数:如 range(4) 相当于: range(0,4)

  例子:遍历[0,10)区间的偶数

  for i in range(0,100,2):
      print(i)
  #执行结果：
  0
  2
  4
  6
  8
  

break和continue

使用break语句跳出当前循环

例子

#查找[0,100)第一个3的倍数
for i in range(0,100):
    if i %3 ==0:
        break

使用continue语句, 回到循环顶端, 判定循环条件,循环条件满足, 则执行下一次循环

#打印[0,10)所有3的倍数
for i in range(0,10):
    if i %3 != 0:
        continue
    print(i)
    
#执行结果
0
3
6
9

pass语句 ->空语句

有时候需要用到 空语句 这样的概念, 什么都不做. 由于没有 {} , 需要有一个专门的语句来占位, 要不缩进就混乱了

if x%2 ==0:
    pass
else:
    do_something

列表解析

用一个表达式构造列表

• 使用for循环将生成的值放在一个列表中

  例子1:

  #生成[0,4)的数字的平方序列
  s = [x**2 for x in range(4)]
  print(s)	#[0, 1, 4, 9]
  

  • 还可以搭配使用if语句

  例子2:

  #获取[0,8)区间中所有的奇数
  evens = [x for x in range(8) if x%2 ==1]
  print(evens)	#[1, 3, 5, 7]
  

函数

注意:最后面的:

• 一些可以被重复使用的代码, 可以提取出来放到函数中.

• Python使用def来定义一个函数. 使用return来返回结果

  • 由于是动态类型,所以不用写返回值的类型

  def Add(x,y):
      return x+y
  

• Python使用()来调用函数

  • 理解 “形参” 和 “实参”: 形参相当于数学中 “未知数” 这样的概念. 实参就是给未知数确定具体的数值.
  • Python中没有 “重载” 这样的概念. 相同名字的函数, 后面的会覆盖前面的.

  def func():
      print("a")
  def func():
      print("b")
  func()  #打印b
  

默认参数

• Python支持默认参数. 函数的参数可以具备默认值,即:调用时没有传参或者少传参,默认为某个数(缺省值)

  def  Add(x = 0,y = 1):
      return x+y
  print(Add(10))  #10+1=11
  print(Add())    #0+1=1
  

解包unpack语法

• Python解包(unpack)语法, 函数返回多个值

  def GetPoint():
      return 100,200
  x,y = GetPoint()
  print(x,y)#100 200
  

占位符

• 假如我只关注y, 不想关注x, 可以使用 _ 作为占位符.

def GetPoint():
    return 100,200
_,y = GetPoint()	#_是占位符
print(y)#200

• 函数也是 “对象”. 一个函数和一个数字, 字符串一样, 都可以定义 “别名” 来引用它.

def Func():
    print("aaa")
print(type(Func))   #直接取函数名打印类型,不需要调用		<class 'function'>
func = Func #func就是函数Func的别名
func();#调用func函数	aaa
print(type(func))	#<class 'function'>

• 函数既然是一个对象, 那么也可以作为另外的一个函数的参数和返回值.

例如:

str = "Mango"
print(len(str))#len函数的返回值作为print函数的参数

文件操作

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

handle = open(file_name,access_mode = 'r')

• file_name是文件的名字. 可以是一个绝对路径, 也可以是相对路径.

  • handle = open('test.txt',access_mode = 'r')	#相对路径
    handle = open('Z:\test.txt',access_mode = 'r')	#绝对路径
    

• access_mode是文件的打开方式. 选项有以下几种

  • ‘r’ : 只读
    ‘w’ : 只写
    ‘a’ : 追加写
    ‘t’ : 按文本方式读写
    ‘b’ : 按二进制方式读写

  例如:写文件

  f = open("...","W")
  f.write('写入的内容')
  

• handle是一个文件句柄, 是一个可迭代的对象. 可以直接使用for循环按行读取文件内容.

for line in handle:
    print(line)

• handle使用完毕, 需要close掉. 否则会引起资源泄露**(一个进程能打开的句柄数目是有限的)**

handle.close()

例子: 统计文本中的词频

一个文本文件中, 每一行是一个单词. 可能有重复. 统计每个单词出现的次数.

in 和 not in 是关键字查找

Bug代码1：

handle = open('test.txt',mode = 'r') #以只读方式,打开Z盘下的test.txt文件
words = {} #创建空字典
#读取
for word in handle:
    word = word[:-1] #切片,去掉最后的换行符\n
    #如果当前行的单词不在字典中,就插入新键值对  否则次数+1
    if word not in words:
        words[word] = 1
    else:
        words[word] +=1 
handle.close()
print(words)

切片的时候出了问题,所以我们换一种方式: 使用字符串的strip函数 :去掉字符串两侧的空白字符

handle = open('test.txt',mode = 'r') #以只读方式,打开Z盘下的test.txt文件
words = {} #创建空字典
#读取
for word in handle:
    word =word.strip()#去掉字符串两侧的空白字符
    #如果当前行的单词不在字典中,就插入新键值对  否则次数+1
    if word not in words:
        words[word] = 1
    else:
        words[word] +=1
handle.close()
print(words)

模块

当我们一个项目的代码量较大的时候, 需要把代码放到多个不同的.py文件中. 起到了命名空间的效果

• 可以通过 import 关键字, 引用其他.py文件中的代码.
• 被引入的这个代码文件, 就称之为 “模块”.
• 被引入的文件, 去掉.py后缀名, 就是模块名.

例子:

add.py的内容:

def Add(x,y):
    return x+y

test.py的内容,直接import模块名 不需要加后缀.py

#方式1:导入模块
import add #导入add文件
print(add.Add(1,2)); #打印3  要利用模块进行调用里面的函数

#方式2:导入模块中的函数,直接调用
from add import Add #导入add模块中的Add函数
print(Add(1,2))#打印3 直接调用Add函数

#还可以import 模块名  然后给模块名取别名
import add
a = add
print(a.Add(1,2))#打印3

运用模块的好处

运用模块,在不同文件命名一样名字的函数,就不会导致覆盖

模块查找顺序

一个模块想要被正确导入,必须放到合适的目录下

• 一个是当前目录,一个是系统目录(python解释器安装目录)

模块查找的顺序, 先是查找当前目录, 然后查找Python的安装目录.

常用函数

开发者涨薪指南

48位大咖的思考法则、工作方式、逻辑体系