python提供了两种基本的数值类型_6.Python基础语法---02基础数据类型

基础数据类型

计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有以下几种：

1.字符串

字符串就是一系列字符。 在Python中， 用引号括起的都是字符串， 其中的引号包括单引号，双引号，三引号，用来表示字符串的话必须成队出现。

单双引号可认为等价如下所示：

"This is a string."

'This is also a string.'

如果'本身也是一个字符，那就可以用""括起来

如果"本身也是字符，那就可以用''括号起来

如下：

'I told my friend, "Python is my favorite language!"'

"The language 'Python' is named after Monty Python, not the snake."

"One of Python's strengths is its diverse and supportive community."

通过\也可以实现换行输入整行输出，显示时不会出现换行

>>> print('line1\

... line2\

... line3')

line1line2line3

>>> print("line1\

... line2\

... line3")

line1line2line3

三引号：三个单引号，三个双引号效果是一样，实现换行输入，显示时换行会出现\n。

>>> print('''line1

... line2

... line3''')

line1

line2

line3

如果写成程序并存为.py文件，就是：

print('''line1

line2

line3''')

1.1 转义字符

特殊的字符：无法“看到”的字符；与语法本身语法有冲突的字符。上述两类字符需要使用转义字符

常见：\n 换行；\r 回车；\'单引号；\t 横向制表符

如果字符串内部既包含'又包含"，可以用转义字符\来标识，比如：

>>> 'I\'m \"OK\"!'

'I\'m "OK"!'

转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也需要要转义，所以\\表示的字符就是\

>>> print('I\'m ok.')

I'm ok.

>>> print('I\'m learning\nPython.')

I'm learning

Python.

>>> print('\\\n\\')

\

\

1.2 原始字符

如果字符串里面有很多字符都需要转义，就需要加很多\。为了简化，Python还允许用r''表示''内部的字符串默认不转义

加r后就不是一个普通字符，而是一个原始字符------所见即所得

单引号，双引号，三引号都支持前面加r，实现不转义

>>> print('\\\t\\')

\ \

>>> print(r'\\\t\\')

\\\t\\

>>> print('c:\northwind\northwest') #\n被转义为回车换行

c:

orthwind

orthwest

>>> print('c:\\northwind\\northwest')

c:\northwind\northwest

>>> print(r'c:\northwind\northwest')

c:\northwind\northwest

1.3 字符串操作与运算

1.3.1 字符大小写

字符串函数:title()首字母大写, upper()大写, lower()小写

name= "Sunny Sun"

print("name.lower:", name.lower())

print("name.upper:", name.upper())

print("name.title:", name.title())

执行结果：

name.lower: sunny sun

name.upper: SUNNY SUN

name.title: Sunny Sun

1.3.2 字符串删除空白

rstrip()(确保字符串末尾没有空白)

lstrip()(确保字符串开头没有空白)

strip() (确保字符串两端没有空白)

上述方法不会改变原值,依然包含空白

print("Languages:\n\tPython\n\tC\n\tJavaScript")

favorite_language = 'python '

print(favorite_language + '23')

print(favorite_language.rstrip() + '23')

favorite_language = ' \tpython'

print(favorite_language)

print(favorite_language.lstrip())

favorite_language = ' \tpython\t '

print(favorite_language + '23')

print(favorite_language.strip() + '23')

执行结果:

Languages:

Python

C

JavaScript

python 23

python23

python

python

python 23

python23

1.3.3 + 字符串拼接

first_name = "denny"

last_name = "lv"

full_name = first_name + " " + last_name

message = "Hello, " + full_name.title() + "!"

print(message)

执行结果：

Hello, Denny Lv!

1.3.4 * 字符串重复叠加

字符串重复

只能与整数相乘（0 或负整数，输出'')

print('World' * 3)

执行结果：

WorldWorldWorld

1.3.5 访问索引

通过索引访问对应字符串中的字符，获取对应位置字符

整数——从0开始取

>>> s = 'Sunny'

>>> s[0]

'S'

>>> s[1]

'u'

>>> s[4]

'y'

负数——字符串末尾开始倒着取

>>> s = 'Sunny'

>>> s[-1]

'y'

>>> s[-2]

'n'

>>> s[-5]

'S'

辅助理解与记忆：

复制原理：helloworld向左复制一份 ======> helloworldhelloworld ======> 0开始向右+1，向左减-1

1.3.6 子字符串访问

获取字符串中的子字符串

截取（正截取，反截取）：负数的意义同获取单个字符串时相同

[x:y] x到y-1 截取到尾标识前面这位

[x:] x到尾 截取到尾

[:y] 头到y-1 从头截取到标识前面这位

>>> s = 'Hello,Python World'

>>> s[0:5]

'Hello'

>>> s[6:12]

'Python'

>>> s[13:18]

'World'

>>> s[0:-13]

'Hello'

>>> s[-12:12]

'Python'

>>> s[-12:-6]

'Python'

>>> s[0:]

'Hello,Python World'

>>> s[:18]

'Hello,Python World'

>>> s[-17:]

'ello,Python World'

>>> s[-18:]

'Hello,Python World'

>>> s[-19:]

'Hello,Python World'

>>> s[:]

'Hello,Python World'

2.数字

2.1 整数 int

Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样。如23，24，-7，2020等

整数无限精度，理论上可以表示无穷大的数，除非内存溢出

与其他语言的区别：

其他语言区分short，int，long，比如Java；

python2有int，long 之分， python3中不做区分

多进制表示与转换

十进制 转十进制 int()

二进制 0b开头(字母大小写均可) 转二进制 bin()

八进制 0o开头(字母大小写均可) 转八进制 oct()

十六进制 0x开头(字母大小写均可) 转十六进制 hex()

Q:多进制的表示和转换是否同样适用浮点数？

A:Python中并不支持浮点数进行上述表示与转换

2.2 浮点数 float

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。

浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x10^9就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的，而浮点数运算则可能会有四舍五入的误差。

结果包含的小数位数可能不确定的,如下所示：

例1

>>> 0.2 + 0.1

0.30000000000000004

>>> 3 * 0.1

0.30000000000000004

例2

dollar = 100

curr_rate = 7.127

print(dollar * curr_rate)

print('{dol}美元能兑换{cny}人民币'.format(dol=dollar, cny= dollar * curr_rate))

SunnyiMac: Sunny$ python3 test.py

712.6999999999999

100美元能兑换712.6999999999999人民币

产生计算误差是因为CPU的浮点运算单元导致的，不可避免，如果需要实现精确计算需要引入一个 decimal 库，后续有时间再深入探讨。//TODO

与其他语言的区别：

其他很多语言是区分单双精度的：单精度 float；双精度 double 比如Java。

python无单双精度之分，其实是双精度。

2.3 complex复数

在数字字面值末尾加上 'j' 或 'J' 会生成虚数（实部为零的复数），你可以将其与整数或浮点数相加来得到具有实部和虚部的复数

2.4 基础算术运算

所有数字类型（复数除外）都支持下列运算基础算术运算

Python 完全支持混合算术：当一个二元运算符用于不同数字类型的操作数时，具有“较窄” 类型的操作数会被扩展为另一个操作数的类型，整数比浮点数更窄，浮点数又比复数更窄。 混合类型数字之间的比较也使用相同的规则。

运算

结果

注释

x + y

加: x 和 y 的和

x - y

减: x 和 y 的差

x * y

乘: x 和 y 的乘积

x / y

除: x 和 y 的商

两个int操作数，结果为float

x // y

整除: x 和 y 的商数

1. 只保留整数部分 2//2， 结果为int。 2.运算结果总是向负无穷的方向舍入 1//2 为 0, (-1)//2 为 -1, 1//(-2) 为 -1 而 (-1)//(-2) 为 0。

x % y

取模

C/C++, C#, JAVA, PHP %是取余;Python中% 是取模。取余运算在计算商值向0方向舍弃小数位；取模运算在计算商值向负无穷方向舍弃小数位

-x

x 取反

+x

x 不变

abs(x)

x 的绝对值或大小

int(x)

将 x 转换为整数

float(x)

将 x 转换为浮点数

complex(re, im)

一个带有实部 re 和虚部 im 的复数。im 默认为0。

c.conjugate()

复数 c 的共轭

两个实部相等，[虚部]互为相反数的复数互为共轭复数

divmod(x, y)

(x // y, x % y)

pow(x, y)

x 的 y 次幂

x ** y

x 的 y 次幂

3.布尔值

整数的子类型 表示真假

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来：

>>> True

True

>>> False

False

>>> 3 > 2

True

>>> 3 > 5

False

True:

非0值，非空字符串，非空列表，非空元组，非空字典为True

False:

0值，空字符串，空列表，空元组，空字典，None为False

3.1转换函数:bool函数

>>> bool(0)

False

>>> bool(1)

True

>>> bool(-1)

True

>>> bool(1.1)

True

>>> bool(-1.1)

True

>>> bool([])

False

>>> bool([1,])

True

3.2 布尔值逻辑运算:and、or和not运算。

and运算是与运算，只有所有都为True，and运算结果才是True：

>>> True and True

True

>>> True and False

False

>>> False and False

False

>>> 5 > 3 and 3 > 1

True

or运算是或运算，只要其中有一个为True，or运算结果就是True：

>>> True or True

True

>>> True or False

True

>>> False or False

False

>>> 5 > 3 or 1 > 3

True

not运算是非运算，它是一个单目运算符，把True变成False，False变成True：

>>> not True

False

>>> not False

True

>>> not 1 > 2

True

4.空值

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型，我们后面会继续讲到。

加餐:

取余与取模的差别

通常取模运算也叫取余运算，它们返回结果都是余数 rem 和 mod 唯一的区别在于:

当 x 和 y 的正负号一样的时候，两个函数结果是等同的；当 x 和 y 的符号不同时，rem 函数结果的符号和 x 的一样，而 mod 和 y 一样。

这是由于这两个函数的生成机制不同，rem 函数采用 fix 函数，而 mod 函数采用了 floor 函数（这两个函数都是用来取整的，fix 函数向 0 方向舍入，floor 函数向无穷小方向舍入）。

rem（x，y）命令返回的是 x-ny，如果 y 不等于 0，其中的 n = fix(x/y)，而 mod(x,y) 返回的是 x-ny，当 y 不等于 0 时，n=floor(x/y)

公式1：

对于整型数x，y来说，取模运算或者求余运算的方法都是：

1.求整数商： n = x/y;

2.计算模或者余数： r = x - n*y;

求模运算和求余运算在第一步不同: 取余运算在取c的值时，向0 方向舍入(fix()函数)；而取模运算在计算c的值时，向负无穷方向舍入(floor()函数)。

Java 取余

public class Test {

public static void main(String []args) {

int a = 36;

int b = 10;

System.out.println(a + " " + b + "整除:" + a/b);

System.out.println(a + " " + b + "取余:" + a%b);

System.out.println("-----");

int c = -36;

int d = 10;

System.out.println(c + " " + d + "整除:" + c/d);

System.out.println(c + " " + d + "取余:" + c%d);

System.out.println("-----");

int e = 36;

int f = -10;

System.out.println(e + " " + f + "整除:" + e/f);

System.out.println(e + " " + f + "取余:" + e%f);

System.out.println("-----");

int g = -36;

int h = -10;

System.out.println(g + " " + h + "整除:" + g/h);

System.out.println(g + " " + h + "取余:" + g%h);

}

}

执行输出：

36 10整除:3

36 10取余:6

-----

-36 10整除:-3

-36 10取余:-6

-----

36 -10整除:-3

36 -10取余:6

-----

-36 -10整除:3

-36 -10取余:-6

Python 取模

a = 36;

b = 10;

print('%d // %d = %d' % (a, b, a//b))

print('%d %% %d = %d' % (a, b, a%b))

a = -36;

b = 10;

print('%d // %d = %d' % (a, b, a//b))

print('%d %% %d = %d' % (a, b, a%b))

a = 36;

b = -10;

print('%d // %d = %d' % (a, b, a//b))

print('%d %% %d = %d' % (a, b, a%b))

a = -36;

b = -10;

print('%d // %d = %d' % (a, b, a//b))

print('%d %% %d = %d' % (a, b, a%b))

执行输出:

36 // 10 = 3

36 % 10 = 6

-36 // 10 = -4

-36 % 10 = 4

36 // -10 = -4

36 % -10 = -4

-36 // -10 = 3

-36 % -10 = -6

公式2：（只针对两个异号整数，并只针对取模）

异号整数取模有另一条逻辑公式

先将两个整数看作是正数，再作除法运算:

1、能整除时，其值为 0

2、不能整除时，其值=除数×(整商+1)-被除数

3、最后调整正负号：模与除数符合要求保持一致除数是正，余数就是正； 除数是负，余数就是负

例：mod(36,-10)=-4

即：36 除以 10 的整数商为 3，加 1 后为 4；其与除数之积为 40；再与被数之差为（40-36=4）；取除数的符号。所以值为 -4。

取余取模的详细计算

rem(36, 10)

36-fix(36/10)*10 = 36-3*10=6

mod(36, 10)

36-floor(36/10)*10 = 36-3*10 = 6

rem(-36, 10)

(-36)-fix((-36)/10)*10 = (-36)-(-3)*10=-6

mod(-36, 10)

(-36)-floor((-36)/10)*10 = (-36)-(-4)*10 = 4

公式2：10*(floor(36/10)+1)-36 = 10*4 -36 = 4 除数保持一致，所有4

rem(36, -10)

36-fix(36/(-10))*(-10) = 36-(-3)*(-10)=6

mod(36, -10)

36-floor(36/(-10))*(-10) = 36-(-4)*(-10)=-4

公式2：10*(floor(36/10)+1)-36 = 10*4 -36 = 4 除数保持一致，所有-4

rem(-36, -10)

(-36)-fix((-36)/(-10))*(-10) = (-36)-3*(-10)=-6

mod(-36, -10)

(-36)-floor((-36)/(-10))*(-10) = (-36)-3*(-10)=-6

扩展

关于字符串格式化

参见

文本序列类型 --- str

字符串是一种 序列类型 ，因此也支持序列类型的各种操作。

字符串的方法

字符串支持许多变换和查找的方法。

格式化字符串字面值

内嵌表达式的字符串字面值。

格式字符串语法

使用 str.format() 进行字符串格式化。

printf 风格的字符串格式化

这里详述了使用 % 运算符进行字符串格式化。

计算机中浮点数的二进制表示方法？浮点数运算的精确性问题？//TODO

除 整除底层逻辑? //TODO