Python快速入门

一.Python是一门动态强类型的的语言，何谓动态强类型语言,如下所示：

（1）动态类型：一个变量在运行过程中，类型可发生变换

（2）静态类型：一个变量在运行过程中，类型不可发生变换

（3）强类型：越不支持隐式类型隐式类型转换转换，类型越强、

（4）弱类型：越支持隐式类型转换，越弱

相对于其它语言，python是解释运行、跨平台、可扩展性强、可嵌入、有丰富的库

二.学一门语言最关心的就是运行环境了，而对于Python而言，其中有两个大版本，Python2和Python3，而这两个版本的语法并不兼容，并不会像Java中的版本是兼容的，此处建议下载Python3以上版本，因为python即将淘汰，去官网下载即可。下载完之后安装时只需一直next，然后在命令窗输入python并回车，若出现以下界面即安装成功，此处只安装Python解释器，安装开发环境此处建议安装（VScode+python插件)或者 （pycharm，需自行破解)

三.进入正题，python基本知识(纯干货）

1.在python可书写复数，在python中可以不用写数据类型若真要写可以看一下格式

num=10.0+5j;
a:int='hehe'

 2.编写python代码时不能有分号之类的，python不支持，但Java，C++之类语言支持

3.在python中int类型无上限，只要你的内存足够大，且在python中统一为双精度，无单精度的说法

4.在python中赋值方式分为链式赋值和多元赋值，例子如下

a=b=10 #链式赋值
x,y=10,20 #多元赋值

5.python对字符串的操作如下所示

name='abcdefch'   #字符串
print(num)        #打印字符串
print(len(name))  #获取长度
print(name[-2])   #从后向前打印字符串
print(name[1:3])  #切片操作，前闭后开
a='hello'
b='world'
print(a+b)        #支持字符串相加，而在JAVA中需要append进行拼接
print(a*3)        #相当于把字符串a打印三遍
c='num=%d' %num   #格式化字符串
c=f'num={num}'    #格式化字符串3.6 以后
print(c)          #打印
print(type(a))    #打印类型

6. 在python中从键盘输入用input，如下所示

s=input("请输入一个字符串")  #相当于scanner
print("s:",s)
print("result:",int(s))    #把s强制转换为int

7. 在python中除法是精确除，不取整，若要取整则用//

print(1/2)  #运行为0.5
print(1//2) #运行为0

8.python中的其它运算如下

num=100**100#算乘方
a=10
b=20
c=30
print(a<b<c)  #比较大小，python中与用and，或用or,非用not
##字符串之间用==比较相等
m='hello'
n='world'
print(a==b) #输出为  false
#比较地址相等用一下两种方法任意一种
print(m is n)
print(id(m)==id(n))
print(id(n))    #id 是内建函数

9.python中的列表、元组 与字典，如下

a=[9,5,2,7]#列表(list)可变对象，可修改
print(len(a))#求长度
b=(9,5,2,7)    # 元组，不可变，不可修改
a={'ip':'127.0.0..1','port':80}#字典
print(a['port'])#打印字典

10python中注释用#，文档注释用见下

def Add(x, y):
 '''
 该函数负责加法运算             #文档字符串
 '''
 return x + y
print(Add.__doc__)#查看注释文档

help(add) #也可采用该方法查看

11.由于python是动态语言，因此python赋值可覆盖如

a=10
a=20
print(a) #输出结果为20

12.python中的代码块

result=input("你会认真学习吗？  1.会  0.不会")
if(result=='1'):
    print('你会好好学习')
elif result=='0':
    print(' 错了')
else:
    print('完了')
#循环语句
num=0
while(num<10):# 打印0-9
     print(num)
     num+=1
for num in range(0,10):#python 的 for相当于JAVA中的foreach,打印0-9
      print(num)
def add(x,y):     #python 中不支持重载，存在多个同名函数后者覆盖前者
    result=x+y
    return result
def add(x,y,z):
    return x+y+z
def get_point():  # 可返回多个值
    x = 10;
    y = 20
    return x, y
x, y = get_point()  # 若不想要其中一个，可用占位符_
print(x, y)
print(type(get_point()))  # 函数名就是一个对象

13.python中的文件操作

# 文件操作
f = open("D:\KSWJJ\Answers\请柬2.docx", "r")  # 文件使用完毕之后需要关闭，要不然下次打开失败
f.close()  # 关闭
for line in f:  # 读文件方式一
    print(line, end='')
lines = f.readlines()  # 一次读完，读完为一个列表
f.write('hello')  # 写文件
# 统计文本中每个词出现的次数，用键值对，字典
f = open("D:\KSWJJ\Answers\请柬2.docx", 'r')
word_dict = {}
for word in f:
    word = word.strip()  # 去掉字符串两侧的空白
    if word in word_dict:
        word_dict[word] += 1
    else:
        word_dict[word] = 1
print(word_dict)

14.python中的模块

# 模块
# 可以再另一个文件写方法，在该文件用import导入
# 一个模块想要被正确导入，必须放到适合的目录
a=b=10 #链式赋值
x,y=10,20 #多元赋值
#交换两个变量
a=10
b=20
a,b=b,a
#locals()内建函数，可看当前作用域的变量
print(locals())
#判断是否为为对象通过id或type,一切皆对象
print(id(mypy01))
print(type(mypy01))
#python中的int是不可变的对象，字符串也不可改
#列表和字典是可变对象

15.python中多线程是假的，引入GIL全局解释器锁。是串行执行的，无法利用多核资源，适合IO密集型，不适合于CPU密集型

16.python中的空对象

s=None;  #无效的，不存在的非法对象
print(type(s))
def function():
    print('hehe')
    ret=function()
    print(ret)
ret=None;
if ret:
    print('hehe')
else:
    print('haha')
isinstance(a)#判断是不是实例

最后送一段Python之禅：

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!