Python--基础认知

1:为什么学习Python

公司建议使用Python,然后自己通过百度和向有学过Python的同学了解了Python。Python这门语言,入门比较简单,它简单易学,生态圈比较强大,涉及的地方比较多,特别是在人工智能,和数据分析这方面。在未来我觉得是往自动化,人工智能这方面发展的,所以学习了Python。

2:通过什么途径学习Python

自学,练项目,到GitHub上面找一些小项目学习。

3:谈谈对Python和其他语言的区别

Python属于解释型语言,当程序运行时,是一行一行的解释,并运行,所以调式代码很方便,开发效率高,还有龟叔给Python定位是任其自由发展、优雅、明确、简单,所以在每个领域都有建树,所有它有着非常强大的第三方库,
 

特点:
语法简洁优美,功能强大,标准库与第三方库都非常强大,而且应用领域也非常广;可移植性,可扩展性,可嵌入性。
 

缺点:
运行速度慢。
- 解释型
    - Python/php  (java、C 编译型)      
- 弱类型
 - Python     (java、C 强类型)
- 动态语言
 - Python     (java、C 静态型)

 (1)与Java相比:在很多方面,Python比java要简单,比如java中所有变量必须声明才能使用,而Python不需要声明,用少量的代码构建出很多功能;(高效的高级数据结构)

(2)与PHP相比:python标准包直接提供了工具,并且相对于PHP代码更易于维护;

(3)Python与C相比:

Python 和 C Python这门语言是由C开发而来

对于使用:Python的类库齐全并且使用简洁,如果要实现同样的功能,Python 10行代码可以解决,C可能就需要100行甚至更多.
对于速度:Python的运行速度相较与C,绝逼是慢了

Python的优势:

1、Python 易于学习;

2、用少量的代码构建出很多功能;(高效的高级数据结构)

3、Python 拥有最成熟的程序包资源库之一;

4、Python完全支持面向对象;

5、Python 是跨平台且开源的;

6、动态类型.

4:简述解释型和编译型编程语言

解释型:就是边解释边执行(Python,php)
编译型:编译后再执行(c、java、c#)

5:Python的解释器种类以及相关特点?

CPython
是官方版本的解释器:CPython。是使用C语言开发的,所以叫CPython。在命令行下运行python就是启动CPython解释器。
CPython是使用最广的Python解释器。教程的所有代码也都在CPython下执行。

IPython
IPython是基于CPython之上的一个交互式解释器,也就是说,IPython只是在交互方式上有所增强,但是执行Python代码的功能和CPython是完全一样的。CPython用>>>作为提示符,而IPython用In [序号]:作为提示符。

PyPy
由Python写的解释器,它的执行速度是最快。PyPy采用JIT技术,对Python代码进行动态编译(注意不是解释),
绝大部分Python代码都可以在PyPy下运行,但是PyPy和CPython有一些是不同的,这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。

Jython
Jython是运行在Java平台上的Python解释器,可以直接把Python代码编译成Java字节码执行。

IronPython
IronPython和Jython类似,只不过IronPython是运行在.Net平台上的Python解释器,可以直接把Python代码编译成.Net的字节码。

小结:
Python的解释器很多,但使用最广泛的还是CPython。如果要和Java或.Net平台交互,最好的办法不是用Jython或IronPython,而是通过网络调用来交互,确保各程序之间的独立性。

6:位和字节的关系

1字节 = 8 位
位(bit),数据存储是以“字节”(Byte)为单位,数据传输是以大多是以“位”(bit,又名“比特”)为单位,一个位就代表一个0或1(即一个二进制),二进制是构成存储器的最小单位,每8个位(bit,简写为b)组成一个字节(Byte,简写为B),字节是最小一级的信息单位。

7:b、B、KB、MB、GB的关系

b --->位(bit)    

B --->字节      一个字节等于8位

1B = 8 bit

1kb = 1024 B

1 MB = 1024 KB

1 GB = 1024 MB

8:PEP8规范

1、使用4个空格而不是tab键进行缩进。
2、每行长度不能超过80
3、使用空行来间隔函数和类,以及函数内部的大块代码
4、必要时候,在每一行下写注释
5、使用文档注释,写出函数注释
6、在操作符和逗号之后使用空格,但是不要在括号内部使用
7、命名类和函数的时候使用一致的方式,比如使用CamelCase来命名类,使用lower_case_with_underscores来命名函数和方法
8、在类中总是使用self来作为默认
9、尽量不要使用魔法方法
10、默认使用UTF-8,甚至ASCII作为编码方式
11、换行可以使用反斜杠,最好使用圆括号
12、不要在一句import中多个库

空格的使用:

各种右括号前不要加空格
逗号、冒号前不要加空格
函数的左括号前不要加空格。如Func(1)
序列的左括号前不要加空格。如list[2]
操作符左右各加一个空格,不要为了对齐增加空格
函数默认参数使用的赋值符左右省略空格
不要将多句语句写在同一行
if/for/while语句中,即使执行语句只有一句,也必须另起一行

包名小写(不含下划线),函数名小写(可含下划线),常量名大写(可含下划线),类名驼峰写法,类属性小写(可含下划线)。

9:通过代码实现如下转换(进制之间转换)

# 二进制转换成十进制-->int
v = "0b1111011"
b = int(v,2)
print(b)  # 123


# 十进制转换成二进制--->bin
v2 = 18
print(bin(int(v2)))
# 0b10010

# 八进制转换成十进制
v3 = "011"
print(int(v3,8))
# 11

# 十进制转换成八进制:---> oct
v4 = 30
print(oct(int(v4)))
# 0o36

# 十六进制转换成十进制:
v5 = "0x12"
print(int(v5,16))
# 18

# 十进制转换成十六进制:---> hex
v6 = 87
print(hex(int(v6)))
# 0x57

10:请编写一个函数实现将IP地址转换成一个整数

请编写一个函数实现将IP地址转换成一个整数。
如 10.3.9.12 转换规则为:
        10            00001010

         3            00000011

         9            00001001

        12            00001100

再将以上二进制拼接起来计算十进制结果:00001010 00000011 00001001 00001100 = ?


def v1(addr):
    # 取每个数
    id = [int(x) for x in addr.split(".")]
    print(id)
    return sum(id[i] << [24, 16, 8, 0][i] for i in range(4))

print(v1("127.0.0.1"))

# [127, 0, 0, 1]
# 2130706433

11:python递归的最大层数?998

12:求结果(and or or)

1. 求结果:1 or 3
print(1 or 3)  # 1

2. 求结果:1 and 3
print(1 and 3)  # 3

3. 求结果:0 and 2 and 1
print(0 and 2 and 1)  # 0

4. 求结果:0 and 2 or 1
print(0 and 2 or 1)  # 1

5. 求结果:0 and 2 or 1 or 4
print(0 and 2 or 1 or 4)  # 1

6. 求结果:0 or Flase and 1
print(0 or False and 1)  # Flase

总结:
  # x or y 如果 x为真,则值为x,   否则为y
  # x and y 如果 x 为真,则值为 y,否则为 x

运算符

1. 求结果:2 & 5(与)

print(2 & 5)  # 10 & 101 => 000 => 0

2. 求结果:2 ^ 5即2 | 5(或)

print(2 ^ 5)  # 10 ^ 101 => 111 => 1*2**0+1*2**1+1*2**2=1+2+4=7

13:ascii、unicode、utf-8、gbk 区别

Python2  内容进行编码(默认ascii),而Python3对内容进行编码的默认为unicode。
ascii    最多只能用8位来表示(1个字节),即:2**8 = 256,所以,ASCII码最多只能表示 256 个符号。
unicode  万国码,任何一个字符占2个字节
utf-8    万国码的升级版  一个中文字符占3个字节   英文是1个字节  欧洲的是2个字节
gbk      国内版本  一个中文字符占2个字节   英文是1个字节
gbk 转 utf-8  需通过媒介 unicode

14:字节码和机器码的区别

机器码,学名机器语言指令,有时也被称为原生码,是电脑的CPU可直接解读的数据。

字节码是一种中间状态(中间码)的二进制代码(文件)。需要直译器转译后才能成为机器码。

什么是机器码
机器码(machine code),学名机器语言指令,有时也被称为原生码(Native Code),是电脑的CPU可直接解读的数据。
通常意义上来理解的话,机器码就是计算机可以直接执行,并且执行速度最快的代码。

总结:机器码是电脑CPU直接读取运行的机器指令,运行速度最快,但是非常晦涩难懂,也比较难编写

什么是字节码
字节码(Bytecode)是一种包含执行程序、由一序列 op 代码/数据对 组成的二进制文件。
字节码是一种中间码,它比机器码更抽象,需要直译器转译后才能成为机器码的中间代码。

总结:字节码是一种中间状态(中间码)的二进制代码(文件)。需要直译器转译后才能成为机器码。

is == 的区别

#is  比较的是内存地址
#==  比较的是值
#int     具有范围:-5---256
#对于int小数据池
范围:-5----256 创建的相间的数字,都指向同一个内存地址

#对于字符串
1、小数据池 如果有空格,那指向两个内存地址,
2、长度不能超过 20
3、不能用特殊字符

i = 'a'*20
j = 'a'*20
print(i is j)   # True

i = "a"*21
j = "a"*21
print(i is j)   # False

15:三元运算写法和应用场景?

应用场景:简化if语句
# 关于三元运算
# 结果+ if  + 条件  + else + 结果
result='gt' if 1>3 else 'lt'
print(result)       # lt
# 理解:如果条件为真,把if前面的值赋值给变量,否则把else后面的值赋值给变量。


lambda 表达式
temp = lambda x,y:x+y
print(temp(4,10))   # 14

可替代:
def foo(x,y):
    return x+y
print(foo(4,10))    # 14

16:Python3和Python2的区别?

1:打印时,py2需要可以不需要加括号,py3 需要
python2 :print ('lili') , print 'lili'
python3 : print ('lili')   
python3 必须加括号

exec语句被python3废弃,统一使用exec函数。

2:内涵
Python2:1,臃肿,源码的重复量很多。
         2,语法不清晰,掺杂着C,php,Java,的一些陋习。
Python3:几乎是重构后的源码,规范,清晰,优雅。

3、输出中文的区别
python2:要输出中文 需加 # -*- encoding:utf-8 -*-
Python3:直接搞

4:input不同
python2 :raw_input
python3 :input 统一使用input函数

5:指定字节
python2在编译安装时,可以通过参数-----enable-unicode=ucs2 或-----enable-unicode=ucs4分别用于指定使用2个字节、4个字节表示一个unicode;
python3无法进行选择,默认使用 ucs4
查看当前python中表示unicode字符串时占用的空间:

impor sys
print(sys.maxunicode)
#如果值是65535,则表示使用usc2标准,即:2个字节表示
#如果值是1114111,则表示使用usc4标准,即:4个字节表示

6:
py2:xrange(返回列表)
   range(返回生成器)
py3:range  统一使用range,Python3中range的机制也进行修改并提高了大数据集生成效率。

7:在包的知识点里
包:一群模块文件的集合 + __init__
区别:py2:必须有__init__
   py3:不是必须的了

8:不相等操作符"<>"被Python3废弃,统一使用"!="

9:long整数类型被Python3废弃,统一使用int

10:迭代器iterator的next()函数被Python3废弃,统一使用next(iterator)

11:异常StandardError 被Python3废弃,统一使用Exception

12:字典变量的has_key函数被Python废弃,统一使用in关键词

13:file函数被Python3废弃,统一使用open来处理文件,可以通过io.IOBase检查文件类型

17:用一行代码实现数值交换

a = 1 
b = 2

a, b = b, a

18:Python3和Python2中int和long区别

在python3里,只有一种整数类型int。大多数情况下,和python2中的长整型类似。

19:xrange和range的区别

都在循环时使用,xrange内存性能更好,xrange用法与range完全相同,range一个生成list对象,xrange是生成器。

要生成很大的数字序列的时候,用xrange会比range性能优很多,因为不需要一上来就开辟一块很大的内存空间。

在Python2中:

range([start,] stop[, step]),根据start与stop指定的范围以及step设定的步长,生成一个序列

xrange用法与range完全相同,所不同的是生成的不是一个数组,而是一个生成器。

由上面的示例可以知道:要生成很大的数字序列的时候,用xrange会比range性能优很多,因为不需要一上来就开辟一块很大的内存空间,这两个基本上都是在循环的时候用。

在 Python3 中,range() 是像 xrange() 那样实现,xrange()被抛弃。

20:文件操作时:xreadlines和readlines的区别?

readlines     返回一个列表

xreadlines   返回一个生成器

21:列列举布尔值为False的常见值?

0,"",{},[],(),set(),False,负数,不成立的表达式,None,等。

22:字符串、列表、元组、字典每个常用的5个方法?

字符串:
字符串用单引号(')或双引号(")括起来,不可变。
s.strip(c):去除空格或指定的字符c;lstrip/rstrip;
s.zfill(w):右对齐,宽度小于w用0前补;
s.ljust(w,c):左对齐,宽度w,填充符c;rjust()右对齐。
s.join(q):用"s"将序列"q"中的元素串起来;	
s.partition(sep):以sep为分隔符,把字符串分割,返回一个元组(包含分割符);
s.split(sep=None, maxsplit=-1):把字符串以sep为分隔符分割,maxsplit为分割次数,返回一个列表(不包含分割符);
s.find(t):返回t的最左位置,未找到,返回-1;
s.index(t):返回t的最左位置,未找到,返回ValueError异常;
s.capitalize():第一个字母变大写;
s.title():每个单词首字母大写;
s.center(width, fillchar=None):字符串内容居中,在给定的字符串长度width中内容居中,两边用提供的字符fillchar填充,fillchar默认为空;
s.count(sub, start=None, end=None):在指定位置start与end之间,计算sub字符的数量;
s.endswith(suffix, start=None, end=None):判断字符串在start与end位置之间是不是以某个子序列suffix结尾,类似方法还可有startwith();
s.replace(old, new, count=None):把字符串中某个子序列old替换成一个新序列new,count是替换数,返回一个新字符串;
s.isdigit():判断是否全是数字;
s.isalpha():判断是否全是字母;
s.isalnum():判断是否包含字母或数字;
s.isspace():判断是否是空字符串;
s[start:stop:step]:切片,截取子字符串。

 

字典:
1:无序(不能索引) 2:数据关联性强 3:键值对,键值对。唯一一个映射数据类型。
字典的键必须是可哈希的,不可变类型。
在同一个字典中,键(key)必须是唯一的。
列表是有序的对象集合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取
1)clear(self):清除字典中的所有元素。
2)copy(self):复制一份元组,相当于一次浅拷贝。 
3)fromkeys(self, iter, value=None):分别以iter中的元素为键,以value为值,创建一个字典。
4)get(self, k, d=None):获取字典中键为k的值,如果字典中不包含k,则给出d值,d默认为None。
5)items(self):遍历字典的一个方法,把字典中每对key和value组成一个元组,并把这些元组放在一个类似列表的dict_items中返回。
6)keys(self):遍历字典键keys的一个方法,返回一个类似列表的dict_keys,与items方法用法相同。
7) values(self):遍历字典值value的一个方法,返回一个类似列表的dict_values,与items方法用法相同。
8)pop(self, k, d=None):弹除并返回字典中键为k的值。
9)popitem(self):从字典中随机取出一组键值,返回一个新的元组。
10)setdefault(self, k, default=None):从字典中获取键为k的值,当存在k时,功能和get基本一致,当字典中不存在k时,在原字典上添加键为k、值为default的项,并返回default值。
11)update(self, E=None, **F):给字典新增元素,没有返回值。用法:dict.update(dict2)。


列表:
索引,切片,加,乘,检查成员。
1、List写在方括号之间,元素用逗号隔开。
2、和字符串一样,list可以被索引和切片。
3、List可以使用+操作符进行拼接。
4、List中的元素是可以改变的。
1)append(self, p_object):在原有列表最后位置上追加新元素到列表,不生成新的列表。
2)clear(self):清空列表里面的元素,不生成新列表。
3)copy(self):复制一份列表,相当于一次浅拷贝。
5)extend(self, iterable):把iterable中的每个元素扩展成列表的元素,iterable可以是字符串、列表、集合、元组、字典。
6)index(self, value, start=None, stop=None):查找列表中value元素索引位置,start与stop参数是查找起始与结束位置,默认为None。
7)insert(self, index, p_object):在列表index索引位置插入元素p_object,当index大于列表包含的元素个数时,在最后位置插入元素。
8)pop(self, index=None):从列表中取出index位置的值,index默认为None,此时弹除并返回列表中最后一个值。
9)remove(self, value):移除列表中第一个出现的value元素,value元素不存在列表中时,则抛出ValueError。
10)reverse(self):反转列表元素的位置。
11)sort(self, key=None, reverse=False):给列表中的元素排序,改变原列表!reverse默认False(升序)。【而sorted()函数是生成副本】。
12)[start:stop:step]:切片,从列表中取出一部分元素生成一个新列表,start与stop默认为None,step表示步长值,默认是一个接着一个切取,
如果为2,则表示进行隔一取一操作。步长值为正时表示从左向右取,如果为负,则表示从右向左取。步长值不能为0。
13)索引[index]:获取索引位置index的值。


元组:
()元组的元素不能修改。
1、与字符串一样,元组的元素不能修改。
2、元组也可以被索引和切片,方法一样。
3、注意构造包含0或1个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接。
1)count(self, value):统计元组中包含value元素的数量,返回一个int值。
2)index(self, value, start=None, stop=None):索引,查找元组中value元素第一个出现的位置,start与stop参数是查找起始与结束位置,默认为None。
3)[start:stop:step]:切片操作。


Set(集合):
集合(set)是一个无序不重复元素的序列。
可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
1)add(self, *args, **kwargs):在集合里添加一个元素,不生成新的集合。
2)clear(self, *args, **kwargs):清空集合里面的元素,不生成新的集合。
3)copy(self, *args, **kwargs):浅拷贝集合,返回一个新集合。
4)difference(self, *args, **kwargs):传入一个或多个参数集合对比,返回一个与参数集合不一样元素的集合。
5)discard(self, *args, **kwargs):删除集合中的某个元素,如果这个元素没有在集合中,不做操作。
6)isdisjoint(self, *args, **kwargs):对比两个集合,若空交集则返回True,没有则返回False。
7)issubset(self, *args, **kwargs):判断集合的包含关系,是否是参数集合的子集。
8)pop(self, *args, **kwargs):从集合中随机(因集合无序)弹除并返回一个元素,如果集合为空,则报TypeError错误。
9)remove(self, *args, **kwargs):移除集合中的一个元素,这个元素必须在集合中,如果不在,则报TypeError错误。
10)union(self, *args, **kwargs):两个集合拼接返回一个新集合。
11)update(self, *args, **kwargs):更新集合,添加集合中没有的新元素,不返回新集合。

23:lambda表达式格式以及应用场景?

匿名函数:为了解决那些功能很简单的需求而设计的一句话函数。
函数名 = lambda 参数 :返回值

#参数可以有多个,用逗号隔开
#匿名函数不管逻辑多复杂,只能写一行,且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以是任意数据类型

lambda 表达式
temp = lambda x,y:x+y
print(temp(4,10))   # 14

可替代:
def foo(x,y):
    return x+y
print(foo(4,10))    # 14

24:pass的作用

pass是空语句,是为了保持程序结构的完整性。pass 不做任何事情,一般用做占位语句。

25:*arg和**kwargs作用

*arg 代表位置参数,它会接收任意多个参数并把这些参数作为元组传递给函数。
**kwargs 代表的关键字参数,返回的是字典,位置参数一定要放在关键字前面。

26. is和==的区别

a = 'lishi'
str1 = "li"
str2 = "shi"
str3 = str1 + str2
print("a == str3",a == str3)
print("a is str3",a is str3)
print("id(a)",id(a))
print("id(str3)",id(str3))
# a == str3 ,True    ==  ---> 只需要内容相等
# a is str3 ,False   is  ---> 只需要内存地址相等
# id(a) 38565848
# id(str3) 39110280

is 比较的是两个实例对象是不是完全相同,它们是不是同一个对象,占用的内存地址是否相同。
== 比较的是两个对象的内容是否相等,即内存地址可以不一样,内容一样就可以了。默认会调用对象的__eq__()方法。

27:谈谈Python的深浅拷贝?以及实现方法和应用场景。

浅拷贝只是增加了一个指针指向一个存在的地址,而深拷贝是增加一个指针并且开辟了新的内存,这个增加的指针指向这个新的内存。采用浅拷贝的情况,释放内存,会释放同一内存,深拷贝就不会出现释放同一内存的错误。

一层的情况:

import copy
 
# 浅拷贝
li1 = [1, 2, 3]
li2 = li1.copy()
li1.append(4)
print(li1, li2)  # [1, 2, 3, 4] [1, 2, 3]
 
# 深拷贝
li1 = [1, 2, 3]
li2 = copy.deepcopy(li1)
li1.append(4)
print(li1, li2)  # [1, 2, 3, 4] [1, 2, 3]

多层的情况:

import copy
 
# 浅拷贝 指向共有的地址
li1 = [1, 2, 3,[4,5],6]
li2 = li1.copy()
li1[3].append(7)
print(li1, li2)  # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5, 7], 6]
 
# 深拷贝 重指向
li1 = [1, 2, 3,[4,5],6]
li2 = copy.deepcopy(li1)
li1[3].append(7)
print(li1, li2)  # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5], 6]

28:Python垃圾回收机制?

引用计数

标记清除

分代回收

29:Python的可变类型和不可变类型?

可变数据类型:列表、字典、集合

不可变数据类型:数字、字符串、元组

 

 

 

 

 

 

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值