Python学习笔记：变量和简单类型


特点：面向对象、解释性、弱类型的脚本语言
跨平台
严格区分大小写

# -*- coding: utf-8 -*-
"""
Created on Tue Aug 11 21:00:33 2020

@author: zh
"""

print("Hello world")

第2章 变量和简单类型

Python 是一 门弱类型语言 ，弱类型包含两方面的含义 ：
①所有的变量无须声明即可使用，或者说对从未用过的变量赋值就是声明了应变量；
②变量的数据类型可以随时改变，同一个变量可以一会儿是数值型，一会儿是字符串型。

单行注释和多行注释

合理的代码注释应该占程序的1/3左右
两种注释：
单行注释：#
多行注释：三个单引号''' 或 三个双引号 """

# 这是一行简单的注释
print("Hello World!")
'''
这里面的内容全部是多行注释
Python语言真的很简单
'''
# print("这行代码被注释了，将不会被编译、执行!")
"""
这是用三个双引号括起来的多行注释
Python同样是允许的。
"""

变量

变量：保存数据
使用等号(=)作为赋值运算符
Python 是弱类型语言 ，弱类型语言有两个典型特征 。
〉变量无须声明即可直接赋值 ： 对一个不存在的变量赋值就相当于定义了一个新变量。
〉变量的数据类型可以动态改变：同一个变量可以一会儿被赋值为整数值， 一会儿被赋值为字符串。

a = 0.1
print(type(a))

a = "0.1"
print(type(a))

a = 5
print(type(a))

结果：
<class 'float'>
<class 'str'>
<class 'int'>

函数就相当于一个有魔法的“黑盒子，你可以向这个“黑盒子”提供一些数据，这个“黑盒子”会对这些数据进行处理，这种处理包括转换和输出结果。
Python程序中使用print()函数来输出变量

name = 'zhangsan'
age = 18
print("名字:",name,"年龄:",age)
print("名字:",name,"年龄:",age,sep='|')

print(40,"\t",end="")
print(50,"\t",end="")
print(60,"\t",end="")

输出：
名字: zhangsan 年龄: 18
名字:|zhangsan|年龄:|18
40 	50 	60

写入log到文件中

f = open("log.txt","w")
print("写入文件中",file=f)
f.close()

Python学习笔记：变量和简单类型
变量的命名规则
使用标识符给变量命名，规则：

  1. 以字母、下划线()开头，后面可以跟任意数目的字母、数字、下划线（）
  2. 数字不能打头
  3. 不能是python关键字，但可以包含关键字
  4. 不能包含空格

Python关键字

import keyword
print(keyword.kwlist)

输出结果：
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

以上这些关键字都不能作为变量名。
Python内置函数

数据类型

整型、浮点型、复数
支持大整数赋值，不会发生溢出问题
Python的整型支持None值(空值)

a = None
print(a)

输出结果：
None

Python学习笔记：变量和简单类型


b = 1_000_000
print(b)

输出：
1000000

浮点型
python不允许除以0

复数**

字符串入门

Python要求必须使用引号括起来，使用单引号也行、使用双引号也行。只要两边的引号能配对即可。


若字符串本身包含了单引号或双引号，需要特殊处理：

  • 使用不同的引号将字符串括起来
  • 对引号进行转义()


拼接字符串

  1. 紧挨着写在一起，会自动拼接它们
b = "Hello,"  '中国' 
print(b)

输出：
Hello,中国
  1. 使用+号做为拼接运算符
b = "Hello,"  '中国' 
c = "加油"
d = b+c
print(d)

输出：
Hello,中国加油


repr和字符串

s1="这本书的价格："
b=99.8
print(s1+b)

输出：
TypeError: can only concatenate str (not "float") to str


s1="这本书的价格："
b=99.8
print(s1+str(b))
print(s1+repr(b))

输出：
这本书的价格：99.8
这本书的价格：99.8

repr还有一个功能：以python表达式的形式来表示值

st="www ddd aa"
print(st)
print(repr(st))

输出：
www ddd aa
'www ddd aa'

使用input和raw_input获取用户输入

msg=input("请输入内容：")
print(type(msg))
print(msg)

输出：
请输入内容：1.2
<class 'str'>
1.2

长字符串
使用三个引号(单引号、双引号)定义长字符串

s='''Hello,it's cat!!!'''
print(s)

输出：
Hello,it's cat!!!

还可以使用转义字符()对换行符进行转义，转义后的换行符不会"中断"字符串

s2="hello,cat cat \
aaa,bbb ccc"
print(s2)

输出：
hello,cat cat aaa,bbb ccc

需要说明：python不是格式自由的语言，换行与缩进都有其规定的语法，python不允许随意换行，如果需要换行，需要使用转移字符()进行转义

num=30+2/3+\
    2*3
print(num)

输出：
36.66666666666667

原始字符串
由于字串中的反斜线都有其特殊作用，因为当字符串中包含反斜线时，就需要对齐进行转义。


原始字符串以“r”开头，原始字符串不会把反斜线当成特殊字符

path=r'C:\Users\zh\Downloads\'
print(path)

输出：
    path=r'C:\Users\zh\Downloads\'
                                  ^
SyntaxError: EOL while scanning string literal

原始字符串包含引号，需要对引号进行转义
原始字符串的反斜线会对引号进行转义

path=r'C:\Users\zh\Downloads'  "\\"
print(path)

输出：
C:\Users\zh\Downloads\

或

path='''C:\\Users\\zh\\Downloads\\'''
print(path)

输出：
C:\Users\zh\Downloads\

字节串
字节串里的每个数据单元是1个字节
Python学习笔记：变量和简单类型


字符集的概念
Python学习笔记：变量和简单类型

深入使用字符串

转义字符

\b 退格符
\n 换行符
\r 回车符
\t 制表符
" 双引号
' 单引号
\ 反斜线

字符串格式化

转换说明符
Python学习笔记：变量和简单类型
print函数包含三部分：第一部分是格式化字符串（它相当于字符串模板），该格式化字符串中包含一个“%s”占位符，它会被第三部分的变量或表达式的值代替，第二部分固定使用“%”作为分隔符。
示例：

price = 108
print("the book's price is %x" % price)
user = "Charli"
age = 8
# 格式化字符串有两个占位符，第三部分提供2个变量
print("%s is a %s years old boy" % (user , age))
num = -28
print("num is: %6i" % num)
print("num is: %6d" % num)
print("num is: %6o" % num)
print("num is: %6x" % num)
print("num is: %6X" % num)
print("num is: %6s" % num)
num2 = 30
# 最小宽度为0，左边补0
print("num2 is: %06d" % num2)
# 最小宽度为6，左边补0，总带上符号
print("num2 is: %+06d" % num2)
# 最小宽度为6，右对齐
print("num2 is: %-6d" % num2)
my_value = 3.001415926535
# 最小宽度为8，小数点后保留3位
print("my_value is: %8.3f" % my_value)
# 最小宽度为8，小数点后保留3位，左边补0
print("my_value is: %08.3f" % my_value)
# 最小宽度为8，小数点后保留3位，左边补0，始终带符号
print("my_value is: %+08.3f" % my_value)
the_name = "Charlie"
# 只保留3个字符
print("the name is: %.3s" % the_name) # 输出Cha
# 只保留2个字符，最小宽度10
print("the name is: %10.2s" % the_name)

输出结果：

the book's price is 6c
Charli is a 8 years old boy
num is:    -28
num is:    -28
num is:    -34
num is:    -1c
num is:    -1C
num is:    -28
num2 is: 000030
num2 is: +00030
num2 is: 30    
my_value is:    3.001
my_value is: 0003.001
my_value is: +003.001
the name is: Cha
the name is:         Ch

序列相关方法

Python字符串直接在方括号[]中使用索引即可获取对应的字符，第一个字符的索引为0，依次类推；也允许从后面开始计算索引，最后一个字符的索引为-1，倒数第二个字符的索引为-2，依次类推。
示例：

s = 'crazyit.org is very good'
# 获取s中索引2处的字符
print(s[2]) # 输出a
# 获取s中从右边开始，索引4处的字符
print(s[-4]) # 输出g
# 获取s中从索引3处到索引5处（不包含）的子串
print(s[3: 5]) # 输出zy
# 获取s中从索引3处到倒数第5个字符的子串
print(s[3: -5]) # 输出zyit.org is very
# 获取s中从倒数第6个字符到倒数第3个字符的子串
print(s[-6: -3]) # 输出y g
# 获取s中从索引5处到结束的子串
print(s[5: ]) # 输出it.org is very good
# 获取s中从倒数第6个字符到结束的子串
print(s[-6: ]) # 输出y good
# 获取s中从开始到索引5处的子串
print(s[: 5]) # 输出crazy
# 获取s中从开始到倒数第6个字符的子串
print(s[: -6]) #输出crazyit.org is ver

输出结果：

a
g
zy
zyit.org is very
y g
it.org is very good
y good
crazy
crazyit.org is ver

Python字符串支持用in运算符判断是否包含某个子串，示例：

s = 'crazyit.org is very good'
# 判断s是否包含'very'子串
print('very' in s) # True
print('fkit' in s) # False

python通过内置的len()函数可以获取子串的长度，示例：

# 输出s的长度
print(len(s)) # 24
# 输出'test'的长度
print(len('test')) # 4

python可使用全局内置的min()和max()函数获取字符串中最小字符和最大字符

# 输出s字符串中最大的字符
print(max(s)) # z
# 输出s字符串中最大的字符
print(min(s)) # 空格

大小写相关方法

dir():列出指定类或模块包含的全部内容（包括函数、方法、类、变量等）
help():查看某个函数或方法的帮助文档
""开头、""结尾的方法被约定成私有方法，不希望被外部直接调用。


Python字符串由内建的str类代表，str类中与大小写相关的常用方法：
title():将每个单词的首字符改为大写
lower():将整个字符串改为小写
upper():将整个字串改为大写
示例：

a = 'our domain is crazyit.org'
# 每个单词首字母大写
print(a.title())
# 每个单词首字母小写
print(a.lower())
# 每个单词首字母大写
print(a.upper())

输出结果：

Our Domain Is Crazyit.Org
our domain is crazyit.org
OUR DOMAIN IS CRAZYIT.ORG

删除空白

str类提供了如下方法删除空白：
strip():删除字符串前后的空白
lstrip():删除字符串前面（左边）的空白
rstrip():删除字符串前面（右边）的空白


Python的str是不可变的(不可变的意思是指，字符串一旦形成，它所包含的字符序列就不能发生任何改变)，因此这三个方法只是返回字符串前面或后面空白被删除之后的副本，并没有真正改变字符串本身。
示例：

s = '  this is a puppy  '
# 删除左边的空白
print(s.lstrip())
# 删除右边的空白
print(s.rstrip())
# 删除两边的空白
print(s.strip())
# 再次输出s，将会看到s并没有改变
print(s)
s2 = 'i think it is a scarecrow'
# 删除左边的i、t、o、w字符
print(s2.lstrip('itow'))
# 删除右边的i、t、o、w字符
print(s2.rstrip('itow'))
# 删除两边的i、t、o、w字符
print(s2.strip('itow'))

输出结果：

this is a puppy  
  this is a puppy
this is a puppy
  this is a puppy  
 think it is a scarecrow
i think it is a scarecr
 think it is a scarecr

查找、替换相关方法

str类提供了如下常用的查找、替换等操作方法

  • startswith:判断字符串是否以指定子串开头
  • endswith:判断字符串是否一指定子串结尾
  • find():查找指定子串在字符串中出现的位置，如果没有找到指定字串，则返回-1
  • index():查找指定子串在字符串中出现的位置，如果没有指定子串，则引发ValueError错误。
  • replace():使用指定子串替换目标字符串中的目标子串
  • translate():使用指定的翻译映射表对字符串执行替换


示例:

s = 'crazyit.org is a good site'
# 判断s是否以crazyit开头
print(s.startswith('crazyit'))
# 判断s是否以site结尾
print(s.endswith('site'))
# 查找s中'org'的出现位置
print(s.find('org')) # 8
# 查找s中'org'的出现位置
print(s.index('org')) # 8
# 从索引为9处开始查找'org'的出现位置
#print(s.find('org', 9)) # -1
# 从索引为9处开始查找'org'的出现位置
# print(s.index('org', 9)) # 引发错误
# 将字符串中所有it替换成xxxx
print(s.replace('it', 'xxxx'))
# 将字符串中1个it替换成xxxx
print(s.replace('it', 'xxxx', 1))
# 定义替换表：97（a）->945（α）,98（b）->945（β）,116（t）->964（τ）,
table = {97: 945, 98: 946, 116: 964}
print(s.translate(table)) # crαzyit.org is α good site

输出结果:

True
True
8
8
crazyxxxx.org is a good sxxxxe
crazyxxxx.org is a good site
crαzyiτ.org is α good siτe

分隔、连接方法

pytho的str类提供了分割和连接的方法：

  • spilt():将字符串按照指定分隔符分割成多个短语
  • join():将多个短语连接成字符串

str类的spilt()和join()方法互为逆操作
示例：

s = 'crazyit.org is a good site'
# 使用空白对字符串进行分割
print(s.split()) # 输出 ['crazyit.org', 'is', 'a', 'good', 'site']
# 使用空白对字符串进行分割,最多只分割前2个单词
print(s.split(None, 2)) # 输出 ['crazyit.org', 'is', 'a good site']
# 使用点进行分割
print(s.split('.')) # 输出 ['crazyit', 'org is a good site']
mylist = s.split()
# 使用'/'为分割符，将mylist连接成字符串
print('/'.join(mylist)) # 输出 crazyit.org/is/a/good/site
# 使用','为分割符，将mylist连接成字符串
print(','.join(mylist)) # 输出 crazyit.org,is,a,good,site

输出结果：

['crazyit.org', 'is', 'a', 'good', 'site']
['crazyit.org', 'is', 'a good site']
['crazyit', 'org is a good site']
crazyit.org/is/a/good/site
crazyit.org,is,a,good,site

运算符

python语言使用运算符将一个或多个操作数连接成可执行语句，用来实现特定功能。
python语言中的运算符可分为如下几种：

  • 赋值运算符
  • 算术运算符
  • 位运算符
  • 索引运算符
  • 比较运算符
  • 逻辑运算符

赋值运算符

用于为常量或变量指定值，使用“=”作为赋值运算符。
支持将一个变量的值赋值给另一个变量；python的赋值表达式是有值的，赋值表达式的值就是被赋的值，因此python支持连续赋值。
示例：

# 为变量st赋值为Python
st = "Python"
# 为变量pi赋值为3.14
pi = 3.14
# 为变量visited赋值为True
visited  = True
print(st)
print(pi)
print(visited)

# 将变量st的值赋给st2
st2 = st
print(st2)

a = b = c = 20
print(a)
print(b)
print(c)

d1 = 12.34
# 将表达式的值赋给d2
d2 = d1 + 5
# 输出d2的值
print("d2的值为：%g" % d2 ) # 17.34

输出结果：

Python
3.14
True
Python
20
20
20
d2的值为：17.34

算术运算符

Python支持所有的基本算术运算符，用于执行基本的数学运算，如加、减、乘、除和求余等。

  • +：加法运算符，还可以作为字符串的连接运算符
  • -：减法运算符，还可以作为求负的运算符
  • *：乘法运算符，还可以作为字符串的连接运算符
  • 除法运算符有两个：“/”表示普通除法，使用它除出来的结果与平常数学计算的结果是相同的（即除不尽时，会有小数部分）；而“//”表示整除，使用它除出来的结果只有整数部分，小数部分将会被舍弃。
  • %：求余运算符
  • ：乘方运算符，开方其实就是乘方的逆运算，因此使用“”也可进行开方运算。
a = 5.2
b = 3.1
the_sum = a + b
# sum的值为8.3
print("the_sum的值为：", the_sum)

s1 = 'Hello, '
s2 = 'Charlie'
# 使用+连接两个字符串
print(s1 + s2)

c = 5.2
d = 3.1
sub = c - d
# sub的值为2.1
print("sub的值为：", sub)

e = 5.2
f = 3.1
multiply = e * f
# multiply的值为16.12
print("multiply的值为：", multiply)

s3 = 'crazyit '
# 使用*将5个字符串连接起来
print(s3 * 5)

print("19/4的结果是:", 19/4)
print("19//4的结果是:", 19//4)
aa = 5.2
bb = 3.1
# aa / bb的值将是1.67741935483871
print("aa/bb的值是:", aa / bb)
# aa // bb值将是1.0
print("aa//bb的值是:", aa // bb)

print('5的2次方：', 5 ** 2) # 25
print('4的3次方：', 4 ** 3) # 64
print('4的开平方：', 4 ** 0.5) # 2.0
print('27的开3次方：', 27 ** (1 / 3)) # 3.0

输出结果：

the_sum的值为： 8.3
Hello, Charlie
sub的值为： 2.1
multiply的值为： 16.12
crazyit crazyit crazyit crazyit crazyit 
19/4的结果是: 4.75
19//4的结果是: 4
aa/bb的值是: 1.6774193548387097
aa//bb的值是: 1.0
5的2次方： 25
4的3次方： 64
4的开平方： 2.0
27的开3次方： 3.0

位运算符

位运算符通常在图形、图像处理和创建设备驱动等底层开发中使用。使用位运算符可以直接操作数值的原始bit位，尤其是在使用自定义的协议进行通信时，使用位运算符对原始数据进行编码和解码也非常有效。
python支持的位运算符有如下6个：

  • &：按位与
  • |：按位或
  • ^：按位异或
  • ~：按位取反
  • <<：左位移运算符

  • ：右位移运算符

Python学习笔记：变量和简单类型
Python学习笔记：变量和简单类型

扩展后的赋值运算符

Python学习笔记：变量和简单类型

索引运算符

索引运算符就是方括号，在方括号中使用单个索引值，也可使用索引范围。实际上，在使用索引范围时，还可指定步长。

a = 'abcdefghijklmn'
# 获取索引2到索引8的子串，步长为3
print(a[2:8:3]) # 输出cf
# 获取索引2到索引8的子串，步长为2
print(a[2:8:2]) # 输出ceg

比较运算符与bool类型

Python学习笔记：变量和简单类型
Python学习笔记：变量和简单类型
实际上true也可被当成整数1使用，False也可被当成整数0使用。也就是说，True、False两个值完全可以参与各种算术运算。

# 输出True
print("5是否大于 4：", 5 > 4)
# 输出False
print("3的4次方是否大于等于90.0：", 3 ** 4 >= 90)
# 输出True
print("20是否大于等于20.0：", 20 >= 20.0)
# 输出True
print("5和5.0是否相等：", 5 == 5.0)
# 输出False
print("True和False是否相等：", True == False)


# 输出True
print("1和True是否相等：", 1 == True)
# 输出True
print("0和False是否相等：", 0 == False)
print(True + False) # 输出1
print(False - True)  # 输出-1

==只比较两个变量的值，is要求两个变量引用同一个对象
Python学习笔记：变量和简单类型

import time
# 获取当前时间
a = time.gmtime()
b =  time.gmtime()
print(a == b) # a和b两个时间相等，输出True
print(a is b) # a和b不是同一个对象，输出False
print(id(a))
print(id(b))

输出结果：

True
False
1761549376968
1761549377112

逻辑运算符

逻辑运算符用于操作bool类型的变量、常量或表达式，逻辑运算的返回值也是bool值。有三个：

  • and：与
  • or：或
  • not：非
# 直接对False求非运算，将返回True
print(not False)
# 5>3返回True，20.0大于10，因此结果返回True
print(5 > 3 and 20.0 > 10)
# 4>=5返回False，"c">"a"返回True。求或后返回True
print(4 >= 5 or "c" > "a")

对于组合逻辑，使用圆括号保证运算顺序非常重要，并且可以提高程序的可读性。

bookName = "疯狂Python"
price = 79
version = "正式版"
if bookName.endswith('Python') and (price < 50 or version == "正式版") :
    print("打算购买这本Python图书")
else:
	print("不购买！")

三目运算符

通过if语句实现三目运算符的功能，可以近似地把这种if语句当成三目运算符
True_statements **if **expression **else **False_statements
先对逻辑表达式 expression 求值，如果逻辑表达式返回True，则执行并返回 True_statements ,如果逻辑表达式返回False，则执行并返回 False_statements
Python学习笔记：变量和简单类型

a = 5
b = 3
st = "a大于b" if a > b else  "a不大于b" 
# 输出"a大于b"
print(st)

# 输出"a大于b"
print("a大于b") if a > b else print("a不大于b")

# 第一个返回值部分使用两条语句，逗号隔开
st = print("crazyit"), 'a大于b' if a > b else  "a不大于b" 
print(st)

# 第一个返回值部分使用两条语句，分号隔开
st = print("crazyit"); x = 20 if a > b else  "a不大于b" 
print(st)
print(x)

c = 5
d = 5
# 下面将输出c等于d
print("c大于d") if c > d else (print("c小于d") if c < d else print("c等于d"))

输出结果：

a大于b
a大于b
crazyit
(None, 'a大于b')
crazyit
None
20
c等于d

in运算符

in运算符用于判断某个成员是否位于序列中，可使用in运算符判断字符串是否包含指定子串、判断序列是否包含子序列。python也提供了in的反义词：not in

s = 'crazyit.org'
print('it' in s) # True
print('it' not in s) # False
print('fkit' in s) # False
print('fkit' not in s) # True

运算符的综合性和优先级

Python学习笔记：变量和简单类型
提醒

  • 不要把一个表达式写的过于复杂，如果一个表达式过于复杂，则把它分成几步来完成
  • 不要过多地依赖运算符的优先级来控制表达式的执行顺序，这样可读性太差，应尽量使用"()"来控制表达式的执行顺序


原文来源于我的语雀，我的微信公众号：细细研磨

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode