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

编程语言 2022-06-07 22:44:03 阅读次数: 0

文章目录

变量和赋值

  • 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()

例子: 统计文本中的词频

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

image-20220317114413033

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)

image-20220317114107317

切片的时候出了问题,所以我们换一种方式: 使用字符串的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)

image-20220317114422309

模块

当我们一个项目的代码量较大的时候, 需要把代码放到多个不同的.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的安装目录.

常用函数

image-20220316090501226

猜你喜欢

转载自blog.csdn.net/chuxinchangcun/article/details/124698855
今日推荐
周排行
服务器配置密钥登录
5.从尾到头打印链表
PAT_Basic Level_Practice_1003 (20)
从Java内存模型讲双重检查锁原理
Gated Self-Matching Networks for Reading Comprehension and Question Answering论文阅读笔记
博客项目注意点
SpringBoot2.x webflux响应式编程实战
二叉树的相关笔记
spring中@RequestBody，bean中属性名和json不一致解决方案
蓝桥杯 传球游戏（dp）
每日归档
更多
2024-12-21(0)
2024-12-20(0)
2024-12-19(0)
2024-12-18(0)
2024-12-17(0)
2024-12-16(0)
2024-12-15(0)
2024-12-14(0)
2024-12-13(0)
2024-12-12(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022