php虚数技巧_Python根本语法02根本数据类型

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

"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''')line1line2line3

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

print('''line1line2line3''')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 learningPython.>>> print('\\\n\\')\\1.2 原始字符

如果字符串里面有很多字符都须要转义，就须要加很多\。
为了简化，Python还许可用r''表示''内部的字符串默认不转义加r后就不是一个普通字符，而是一个原始字符------所见即所得单引号，双引号，三引号都支持前面加r，实现不转义

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

>>> print('c:\northwind\northwest') #\n被转义为回车换行c:orthwindorthwest>>> print('c:\\northwind\\northwest')c:\northwind\northwest>>> print(r'c:\northwind\northwest')c:\northwind\northwest1.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 sunname.upper: SUNNY SUNname.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 JavaScriptpython 23python23 pythonpython python 23python23

1.3.3 + 字符串拼接

first_name = "denny"last_name = "lv"full_name = first_name + " " + last_namemessage = "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等

多进制表示与转换十进制 转十进制 int()二进制 0b开头(字母大小写均可) 转二进制 bin()八进制 0o开头(字母大小写均可) 转八进制 oct()十六进制 0x开头(字母大小写均可) 转十六进制 hex()

Q:多进制的表示和转换是否同样适用浮点数？A:Python中并不支持浮点数进行上述表示与转换

浮点数也便是小数，之以是称为浮点数，是由于按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，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.10.30000000000000004>>> 3 0.10.30000000000000004

例2

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

SunnyiMac: Sunny$ python3 test.py712.6999999999999100美元能兑换712.6999999999999公民币

产生打算偏差是由于CPU的浮点运算单元导致的，不可避免，如果须要实现精确打算须要引入一个 decimal 库，后续有韶光再深入磋商。
//TODO

与其他措辞的差异：其他很多措辞是区分单双精度的：单精度 float；双精度 double 比如Java。
python无单双精度之分，实在是双精度。

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

所有数字类型（复数除外）都支持下列运算根本算术运算Python 完备支持稠浊算术：当一个二元运算符用于不同数字类型的操作数时，具有“较窄” 类型的操作数会被扩展为另一个操作数的类型，整数比浮点数更窄，浮点数又比复数更窄。
稠浊类型数字之间的比较也利用相同的规则。

运算结果注释x + y加: x 和 y 的和x - y减: x 和 y 的差x y乘: x 和 y 的乘积x / y除: x 和 y 的商两个int操作数，结果为floatx // 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方向舍弃小数位；取模运算在打算商值向负无穷方向舍弃小数位-xx 取反+xx 不变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 yx 的 y 次幂

整数的子类型 表示真假布尔值和布尔代数的表示完备同等，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请把稳大小写），也可以通过布尔运算打算出来：

>>> TrueTrue>>> FalseFalse>>> 3 > 2True>>> 3 > 5False

True:非0值，非空字符串，非空列表，非空元组，非空字典为TrueFalse:0值，空字符串，空列表，空元组，空字典，None为False

>>> bool(0)False>>> bool(1)True>>> bool(-1)True>>> bool(1.1)True>>> bool(-1.1)True>>> bool([])False>>> bool([1,])True3.2 布尔值逻辑运算:and、or和not运算。
and运算是与运算，只有所有都为True，and运算结果才是True：

>>> True and TrueTrue>>> True and FalseFalse>>> False and FalseFalse>>> 5 > 3 and 3 > 1Trueor运算是或运算，只要个中有一个为True，or运算结果便是True：

>>> True or TrueTrue>>> True or FalseTrue>>> False or FalseFalse>>> 5 > 3 or 1 > 3Truenot运算是非运算，它是一个单目运算符，把True变成False，False变成True：

>>> not TrueFalse>>> not FalseTrue>>> not 1 > 2True4.空值

空值是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)

对付整型数x，y来说，取模运算或者求余运算的方法都是：1.求整数商： n = x/y;2.打算模或者余数： r = x - ny;

求模运算和求余运算在第一步不同: 取余运算在取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整除:336 10取余:6------36 10整除:-3-36 10取余:-6-----36 -10整除:-336 -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 = 336 % 10 = 6-36 // 10 = -4-36 % 10 = 436 // -10 = -436 % -10 = -4-36 // -10 = 3-36 % -10 = -6公式2：（只针对两个异号整数，并只针对取模）

异号整数取模有另一条逻辑公式先将两个整数看作是正数，再作除法运算:1、能整除时，其值为 02、不能整除时，其值=除数×(整商+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-310=6mod(36, 10)36-floor(36/10)10 = 36-310 = 6rem(-36, 10)(-36)-fix((-36)/10)10 = (-36)-(-3)10=-6mod(-36, 10)(-36)-floor((-36)/10)10 = (-36)-(-4)10 = 4公式2：10(floor(36/10)+1)-36 = 104 -36 = 4 除数保持同等，所有4rem(36, -10)36-fix(36/(-10))(-10) = 36-(-3)(-10)=6mod(36, -10)36-floor(36/(-10))(-10) = 36-(-4)(-10)=-4公式2：10(floor(36/10)+1)-36 = 104 -36 = 4 除数保持同等，所有-4rem(-36, -10)(-36)-fix((-36)/(-10))(-10) = (-36)-3(-10)=-6mod(-36, -10)(-36)-floor((-36)/(-10))(-10) = (-36)-3(-10)=-6扩展关于字符串格式化拜会文本序列类型 --- str字符串是一种 序列类型 ，因此也支持序列类型的各种操作。
字符串的方法字符串支持许多变换和查找的方法。
格式化字符串字面值内嵌表达式的字符串字面值。
格式字符串语法利用 str.format() 进行字符串格式化。
printf 风格的字符串格式化这里详述了利用 % 运算符进行字符串格式化。
打算机中浮点数的二进制表示方法？浮点数运算的精确性问题？//TODO除 整除底层逻辑? //TODO