【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
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022