Python是一门弱类型语言，弱类型包含两个方面的含义：

变量无需声明即可直接赋值：所有的变量无需声明即可使用（对从未用过的变量赋值就是声明了该变量）
变量的数据类型可以动态改变：变量的数据类型可以随时改变（同一个变量可以一会儿是数字型，一会儿字符串型）

单行注释和多行注释

合理的代码注释应该占源代码的1/3左右

【1】单行注释：
print("这是单行注释")     #  这是单行注释



【2】多行注释：

'''
三个单引号的多行注释
'''

"""
三个双引号的多行注释
"""

变量

常量与变量的区别：

常量一旦保存了某个数据之后，该数据就不能发生改变；

变量保存的数据则可以多次发生改变，只要程序对变量重新赋值即可。

【1】print（）输出函数：

print(value,...,sep = ' ',end = '\n',file = sys.stdout,flush = False)

使用 print（）函数输出多个变量时，print（）函数默认以空格隔开多个变量，如果改变默认的分隔符，可以通过 sep 参数设置

print("读者姓名：", user_name, "年龄：", user_age, sep = "|")

读者姓名：| XXX | 年龄：| 8

print（）函数输出换行，原因是有一个end参数默认值为“\n”

print(40,'\t',end="")
print(80,'\t',end="")
print(100,'\t',end="")

40  80  100

file参数指定print（）语句的输出目标，file 参数默认值为sys.stdout,该默认值代表系统标准输出，也就是输出到屏幕，因此print（）函数默认输出到屏幕。

实际上，可以通过修改该参数让print()函数输出到特定的文件中

f = open("poem.txt","w") # 打开文件以便写入

print("沧海一粟", file = f)

f.close()

print（）函数的flush参数用于控制输出缓存，该参数一般保持False即可，这样可以获得较好的性能

【2】变量名的命名规则：

（1）变量命名可以使用字母（不局限于26个英文字母，可以包含中文字符、日文字符等）、数字、下划线。但是不能以数字开头；不能是Python关键字、但是可以包含关键字；不能包含空格

Python2.x对中文支持较差，如果要在Python2.x中使用中文字符集或中文变量，需要在源代码第一行加入 # coding: utf-8, 同时将原文件保存为UTF-8字符集【在Python2.x中，print 是关键字而不是函数】

如果使用关键字作为变量名，会报错！

如果使用内置函数作为变量名，不会报错！但是内置函数就会被这个变量覆盖了，该内置函数就不能使用了！

（2）严格区分大小写：abc与ABC截然不同

数值类型

【1】整型
a = None
print(a)
print(type(a))

a = 56
print(a)
print(type(a))

a = 9999999999999999999999999999999
print(a)
print(type(a))

输出：
None
<class 'NoneType'>
56
<class 'int'>
9999999999999999999999999999999
<class 'int'>



# 但是Python2.x时候
a = 9999999999999999999999999999999
print(a)
print(type(a))

输出：
9999999999999999999999999999999
<class 'long'>

Python的整型数值有四种表示形式：

十进制：一般使用的整数

二进制：以 0B或0b 开头

八进制：以 0O或0o 开头

十六进制：以 0X或0x 开头【10-15分别以a~f来表示】

# 以0x或0X开头的整数数值是十六进制的整数
hex_value1 = 0x13
hex_value2 = 0XaF
print("hex_value1的值为：", hex_value1)
print("hex_value2的值为：", hex_value2)
# 以0b或0B开头的整数数值是二进制的整数
bin_val = 0b111
print('bin_val的值为：', bin_val)
bin_val = 0B101
print('bin_val的值为：', bin_val)
# 以0o或0O开头的整数数值是八进制的整数
oct_val = 0o54
print('oct_val的值为：', oct_val)
oct_val = 0O17
print('oct_val的值为：', oct_val)
# 在数值中使用下画线     【Python3.x允许为数值（包括浮点型）增加下画线为分隔符，这些下画线不会影响数值本身。Python2.x不支持数值中使用下画线！】
one_million = 1_000_000
print(one_million)
price = 234_234_234  # price实际的值为234234234
android = 1234_1234  # android实际的值为12341234

输出：
hex_value1的值为： 19
hex_value2的值为： 175
bin_val的值为： 7
bin_val的值为： 5
oct_val的值为： 44
oct_val的值为： 15
1000000

【2】浮点型

浮点型数值用于保存带小数点的数值

Python的浮点数的两种表示形式：

（1）十进制形式：平常简单的浮点数。例如5.12, 7.2， 2.0等【注意：浮点数必须包含一个小数点，否则会被当成整数类型处理】

（2）科学计数形式：例如5.12e2（即5.12 X 10^2）、5.12E2（即5.12 X 10^2）
【切记：只有浮点型数值才可以使用科学计数形式表示，科学计数形式会被自动转为浮点型，例如51200是一个整型值，但是512E2是一个浮点型值】

af1 = 5.2345556
# 输出af1的值
print("af1的值为:", af1)
af2 = 25.2345
print("af2的类型为:", type(af2))
f1 = 5.12e2
print("f1的值为:", f1)
f2 = 5e3
print("f2的值为:", f2)
print("f2的类型为:", type(f2))  # 看到类型为float

输出：
af1的值为: 5.2345556
af2的类型为: <class 'float'>
f1的值为: 512.0
f2的值为: 5000.0
f2的类型为: <class 'float'>

【3】复数

复数的虚部用 j 或 J 来表示

需要导入 cmatch模块（c代表complex）

ac1 = 3 + 0.2j
print(ac1)
print(type(ac1))  # 输出 complex类型
ac2 = 4 - 0.1j
print(ac2)
# 复数运行
print(ac1 + ac2)  # 输出 (7+0.1j)

# 导入cmatch模块
import cmath
# sqrt()是cmath模块下的函数，用于计算平方根
ac3 = cmath.sqrt(-1)
print(ac3)  # 输出 1j

输出：
(3+0.2j)
<class 'complex'>
(4-0.1j)
(7+0.1j)
1j

字符串入门

提示：Python3.x对中文字符支持比较好，但是Python2.x则需要在源代码中增加 "#coding:utf-8 "才能支持中文字符

字符串和转义字符

对于字符串本身包含单引号或双引号的解决方案：

【1】使用不同的引号将字符串括起来：

如果字符串内容中包含了单引号，则可以使用双引号

如果字符串内容中包含了双引号，则可以使用单引号

总结口令：含单用双；含双用单
```
  str1 = "I'm a coder"
  str2 = 'he said:"you are a boy?"'
```
【2】使用转义字符：

反斜线（ \ ）
```
  str1 = 'he said: "I\'m a coder"'
```
其他转义字符：

\b 退格符

\n 换行符

\r 回车符

\t 制表符

'' 双引号

' 单引号

\ 反斜线

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

拼接字符串

s1 = "hello,"   "word"
print(s1)
输出：【注意：两个字符串紧挨写在一起，Python会自动拼接他们，但是并不能真正用于字符串拼接，正确应该用加号（+）拼接】
hello,word

s1 = "hello,"   
s2 = "word"
print(s1+s2)
输出：
hello,word

repr和字符串

Python不可以直接拼接数值和字符串，必须先将数值转为字符串

s1 = "这本书的价格是："
p = 99.8

字符串直接拼接数值，程序报错
print(s1 + p)  # 报错！！！
# 函数1：使用str()将  数值---->字符串
print(s1 + str(p))
# 函数2：使用repr()将 数值---->字符串
print(s1 + repr(p))


repr()还有一个功能，就是他会以Python表达式的形式来表示值，即用单引号括起来，再输出

st = "I will play my fife"
print(st)
print(repr(st)) 


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

I will play my fife
'I will play my fife'   #【这就是字符串的Python的表达式形式】

input和raw_input

input()：函数总会将输入的内容放入字符串中

Python3.x
msg = input("请输入你的值：")
print(type(msg))
print(msg)

输出：
请输入你的值：2.3
<class 'str'>
2.3

请输入你的值：2.3 4.5 3
<class 'str'>
2.3 4.5 3

raw_input()：Python2.x提供的，相当于Python3.x的input（）。

Python2.x也有input（）但是输入字符串时候必须使用引号将字符串括起来，否则报错！

另外，Python2.x的input会判别输入的对应的值的类型

  Python2.x
  msg = input("请输入你的值：")
  print(type(msg))
  print(msg)
  
  输出：
  请输入你的值：2.3
  <class 'float'>
  2.3

长字符串

当有大段字符串（内容又包含单引号或双引号时），推荐使用长字符串形式，赋值给变量【不赋值就单纯注释了】

s = '''"Let's go fishing", said Mary.
"OK, Let's go", said her brother.
they walked to a lake'''
print(s)
print("#" * 10)

【使用换行符进行转义，转义后的换行符不会“中断”字符串!!!】
s2 = 'The quick brown fox \
jumps over the lazy dog'
print(s2)
print("#" * 10)

【对表达式换行，必须使用转义字符（\）!!!】
num = 20 + 3 / 4 + \
      2 * 3
print(num)

输出：
"Let's go fishing", said Mary.
"OK, Let's go", said her brother.
they walked to a lake
##########
The quick brown fox jumps over the lazy dog
##########
26.75

原始字符串

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

s11 = 'G:\\publish\\codes\\02\\2.4'  # 不是原始字符串表示时，需要使用转义字符
s12 = r'G:\publish\codes\02\2.4'  # 使用原始字符串形式
print(s11)
print(s12)

输出：
G:\publish\codes\02\2.4
G:\publish\codes\02\2.4


# 原始字符串包含的引号，同样需要转义，但此时用于转义的反斜线会变成字符串的一部分
s2 = r'"Let\'s go", said Charlie'
print(s2)
 # 由于原始字符串中的反斜线会对引号进行转义，因此原始字符串的结尾处不能是反斜线，否则字符串的结尾处的引号就被转义了，这样就导致字符串不能正常结束。解决方案如下
s3 = r'Good Morning' '\\'
print(s3)
s3 = r'Good Morning' '\\'
print(s3)
s4 = """Good Morning\ """   # 最后面空开一空格，连在一块还是会被转义，导致报错！
print(s4)

输出：
"Let\'s go", said Charlie
Good Morning\
Good Morning\

字节串（bytes）

字符串（str）由多个字符组成，以字符为操作单位

字节串（bytes）由多个字节组成，以字节为操作单位

计算机底层：

位（bit）代表1位，要么是1，要么是0

字节（Byte）代表1字节，1字节包含8位

# 创建一个空的bytes
b1 = bytes()
# 创建一个空的bytes值
b2 = b''
# 通过b前缀指定hello是bytes类型的值
b3 = b'hello'
print(b3)
print(b3[0])
print(b3[2:4])
print()

# 调用bytes方法将字符串转成bytes对象
b4 = bytes('我爱Python编程', encoding='utf-8')
print(b4)
# 利用字符串的encode()方法编码成bytes，默认使用utf-8字符集
b5 = "学习Python很有趣".encode('utf-8')
print(b5)
print()

# 将bytes对象解码成字符串，默认使用utf-8进行解码。
st = b5.decode('utf-8')
print(st)  # 学习Python很有趣

输出：
b'hello'
104
b'll'

b'\xe6\x88\x91\xe7\x88\xb1Python\xe7\xbc\x96\xe7\xa8\x8b'
b'\xe5\xad\xa6\xe4\xb9\xa0Python\xe5\xbe\x88\xe6\x9c\x89\xe8\xb6\xa3'

学习Python很有趣

字符串格式化

price = 108
print("the book's price is %x" % price)  # the book's price is 6c
user = "Charli"
age = 8
# 格式化字符串有两个占位符，第三部分提供2个变量
print("%s is a %s years old boy" % (user, age))  # Charli is a 8 years old boy
num = -28  【指定了字符串的最小宽度为6，因此程序转换数值的时候总宽度为6，不够在前面自动补充空格，这里补充了三个空格】
print("num is: %6i" % num) # num is:    -28
print("num is: %6d" % num) # num is:    -28
print("num is: %6o" % num) # num is:    -34
print("num is: %6x" % num) # num is:    -1c
print("num is: %6X" % num) # num is:    -1C
print("num is: %6s" % num) # num is:    -28
num2 = 30
# 最小宽度为6，左边补0
print("num2 is: %06d" % num2) # num2 is: 000030


# 最小宽度为6，左边补0，总带上符号
【（+）表示数值总要带着符号，正数带“+”，负数带“-”    （0）表示不补充空格，而是补充0】
print("num2 is: %+06d" % num2) # num2 is: +00030
# 最小宽度为6，右对齐
【右对齐由(-)符号表示】
print("num2 is: %-6d" % num2) # num2 is: 30 


my_value = 3.001415926535
# 最小宽度为8，小数点后保留3位
print("my_value is: %8.3f" % my_value)   # my_value is:    3.001
# 最小宽度为8，小数点后保留3位，左边补0
print("my_value is: %08.3f" % my_value)  # my_value is: 0003.001
# 最小宽度为8，小数点后保留3位，左边补0，始终带符号
print("my_value is: %+08.3f" % my_value) # my_value is: +003.001


the_name = "Charlie"
# 只保留3个字符
print("the name is: %.3s" % the_name)    # the name is: Cha
# 只保留2个字符，最小宽度10
print("the name is: %10.2s" % the_name)  # the name is:         Ch







c r a z y i t . o r g   i s   v e r y   g o o d
0 1 2 3 4 5 6 7 8 9 ...........................
.........................................  -2 -1

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
# 判断s是否包含'very'子串
print('very' in s)  # True
print('fkit' in s)  # False
# 输出s的长度
print(len(s))  # 24
# 输出'test'的长度
print(len('test'))  # 4
# 输出s字符串中最大的字符
print(max(s))  # z
# 输出s字符串中最小的字符
print(min(s))  # 空格

字符串大小写，删除空白

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

print(a.swapcase()) # 翻转string中的大小写
print(a.capitalize()) # 把字符串的第一个字符大写

输出：
Our Domain Is Crazyit.Org
our domain is crazyit.org
OUR DOMAIN IS CRAZYIT.ORG
s = '  this is a puppy  '
# 删除左边的空白
print(s.lstrip())
# 删除右边的空白
print(s.rstrip())
# 删除两边的空白
print(s.strip())
# 再次输出s，将会看到s并没有改变
print(s)

输出：
this is a puppy  
  this is a puppy
this is a puppy
  this is a puppy 

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

输出：
 think it is a scarecrow
i think it is a scarecr
 think it is a scarecr

查找、替换相关方法

startswith（）：判断字符串是否以指定子串开头

endswith（）：判断字符串是否以指定子串结尾

find（）：查找指定子串在字符串中出现的位置，如果没有找到指定子串，则返回-1

rfind（）：类似find（），不过是从右边开始查找

index（）：查找指定子串在字符串中出现的位置，如果没有找到指定子串，则引ValueError错误

rindex（）：类似index（），不过是从右边开始

replace（）：使用指定子串替换字符串中的目标子串

string.replace(old_str, new_str, num=string.count(old))，把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次

translate（）：使用指定的翻译映射表对字符串执行替换

s = 'crazyit.org is a good site'
# 判断s是否以crazyit开头
print(s.startswith('crazyit')) # True
# 判断s是否以site结尾
print(s.endswith('site')) # True
print(s.endswith('te')) # True
# 查找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')) # crazyxxxx.org is a good sxxxxe
# 将字符串中1个it替换成xxxx
print(s.replace('it', 'xxxx', 1)) # crazyxxxx.org is a good site
# 定义替换表：97（a）->945（α）,98（b）->945（β）,116（t）->964（τ）,
table = {97: 945, 98: 946, 116: 964}   制作映射表的方法可以使用str的maketrans()方法----->str.maketrans("abc","123")===>{97:49, 98:50, 99:51}
print(s.translate(table))  # crαzyiτ.org is α good siτe 【这里的某些字符时无法正常显示，被替换了，换了部分字符集的映射】

分割、连接方法

split（）：将字符串按照指定的分割符分割成多个短语

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


使用 “.” 对字符串进行分割,最多只分割前3个单词
s = 'crazyit.org i.s a g.ood site'
print(s.split('.', 3)) # ['crazyit', 'org i', 's a g', 'ood site']

判断方法

方法	说明
string.isspace()	如果 string 中只包含空格，则返回 True
string.isalnum()	检测字符串是否由字母和数字组成。如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True
string.isdecimal()	如果 string 只包含数字则返回 True，全角数字
string.isdigit()	如果 string 只包含数字则返回 True，全角数字、⑴、\u00b2
string.isnumeric()	如果 string 只包含数字则返回 True，全角数字，汉字数字
string.istitle()	如果 string 是标题化的(每个单词的首字母大写)则返回 True
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True

文本对齐

方法	说明
string.ljust(width)	返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串
string.rjust(width)	返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串
string.center(width)	返回一个原字符串居中，并使用空格填充至长度 width 的新字符串

拆分与连接

方法	说明
string.partition(str)	把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面)
string.rpartition(str)	类似于 partition() 方法，不过是从右边开始查找
string.split(str="", num)	以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 '\r', '\t', '\n' 和空格
string.splitlines()	按照行('\r', '\n', '\r\n')分隔，返回一个包含各行作为元素的列表
string.join(seq)	以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串

Loading

言非の博客

机器学习、复杂网络

弱类型语言的含义-注释-变量-字符串-命名