MARC

 008260202s2022        xx            o                  0  eng  d
■001EBC6943475
■003MiAaPQ
■00520260202073946.0
■006m          o    d  |            
■007cr  cnu||||||||
■020    ▼a9781492056300▼q(electronic  bk.)
■020    ▼z9781492056355
■035    ▼a(MiAaPQ)EBC6943475
■035    ▼a(Au-PeEL)EBL6943475
■035    ▼a(OCoLC)1313892453
■040    ▼aMiAaPQ▼beng▼erda▼epn▼cMiAaPQ▼dMiAaPQ
■0820  ▼a005.13/3
■1001  ▼aRamalho,  Luciano.
■24510▼aFluent  Python
■250    ▼a2nd  ed.
■264  1▼aSebastopol▼bO'Reilly  Media,  Incorporated▼c2022.
■264  4▼c?022.
■300    ▼a1  online  resource  (1011  pages)
■336    ▼atext▼btxt▼2rdacontent
■337    ▼acomputer▼bc▼2rdamedia
■338    ▼aonline  resource▼bcr▼2rdacarrier
■5050  ▼aCover  --  Copyright  --  Table  of  Contents  --  Preface  --  Who  This  Book  Is  For  --  Who  This  Book  Is  Not  For  --  Five  Books  in  One  --  How  the  Book  Is  Organized  --  Hands-On  Approach  --  Soapbox:  My  Personal  Perspective  --  Companion  Website:  fluentpython.com  --  Conventions  Used  in  This  Book  --  Using  Code  Examples  --  O'Reilly  Online  Learning  --  How  to  Contact  Us  --  Acknowledgments  --  Acknowledgments  for  the  First  Edition  --  Part  I.  Data  Structures  --  Chapter  1.  The  Python  Data  Model  --  What's  New  in  This  Chapter  --  A  Pythonic  Card  Deck  --  How  Special  Methods  Are  Used  --  Emulating  Numeric  Types  --  String  Representation  --  Boolean  Value  of  a  Custom  Type  --  Collection  API  --  Overview  of  Special  Methods  --  Why  len  Is  Not  a  Method  --  Chapter  Summary  --  Further  Reading  --  Chapter  2.  An  Array  of  Sequences  --  What's  New  in  This  Chapter  --  Overview  of  Built-In  Sequences  --  List  Comprehensions  and  Generator  Expressions  --  List  Comprehensions  and  Readability  --  Listcomps  Versus  map  and  filter  --  Cartesian  Products  --  Generator  Expressions  --  Tuples  Are  Not  Just  Immutable  Lists  --  Tuples  as  Records  --  Tuples  as  Immutable  Lists  --  Comparing  Tuple  and  List  Methods  --  Unpacking  Sequences  and  Iterables  --  Using  *  to  Grab  Excess  Items  --  Unpacking  with  *  in  Function  Calls  and  Sequence  Literals  --  Nested  Unpacking  --  Pattern  Matching  with  Sequences  --  Pattern  Matching  Sequences  in  an  Interpreter  --  Slicing  --  Why  Slices  and  Ranges  Exclude  the  Last  Item  --  Slice  Objects  --  Multidimensional  Slicing  and  Ellipsis  --  Assigning  to  Slices  --  Using  +  and  *  with  Sequences  --  Building  Lists  of  Lists  --  Augmented  Assignment  with  Sequences  --  A  +=  Assignment  Puzzler  --  list.sort  Versus  the  sorted  Built-In  --  When  a  List  Is  Not  the  Answer  --  Arrays  --  Memory  Views  --  NumPy  --  Deques  and  Other  Queues  --  Chapter  Summary  --  Further  Reading  --  Chapter  3.  Dictionaries  and  Sets.
■5058  ▼aWhat's  New  in  This  Chapter  --  Modern  dict  Syntax  --  dict  Comprehensions  --  Unpacking  Mappings  --  Merging  Mappings  with  |  --  Pattern  Matching  with  Mappings  --  Standard  API  of  Mapping  Types  --  What  Is  Hashable  --  Overview  of  Common  Mapping  Methods  --  Inserting  or  Updating  Mutable  Values  --  Automatic  Handling  of  Missing  Keys  --  defaultdict:  Another  Take  on  Missing  Keys  --  The  __missing__  Method  --  Inconsistent  Usage  of  __missing__  in  the  Standard  Library  --  Variations  of  dict  --  collections.OrderedDict  --  collections.ChainMap  --  collections.Counter  --  shelve.Shelf  --  Subclassing  UserDict  Instead  of  dict  --  Immutable  Mappings  --  Dictionary  Views  --  Practical  Consequences  of  How  dict  Works  --  Set  Theory  --  Set  Literals  --  Set  Comprehensions  --  Practical  Consequences  of  How  Sets  Work  --  Set  Operations  --  Set  Operations  on  dict  Views  --  Chapter  Summary  --  Further  Reading  --  Chapter  4.  Unicode  Text  Versus  Bytes  --  What's  New  in  This  Chapter  --  Character  Issues  --  Byte  Essentials  --  Basic  Encoders/Decoders  --  Understanding  Encode/Decode  Problems  --  Coping  with  UnicodeEncodeError  --  Coping  with  UnicodeDecodeError  --  SyntaxError  When  Loading  Modules  with  Unexpected  Encoding  --  How  to  Discover  the  Encoding  of  a  Byte  Sequence  --  BOM:  A  Useful  Gremlin  --  Handling  Text  Files  --  Beware  of  Encoding  Defaults  --  Normalizing  Unicode  for  Reliable  Comparisons  --  Case  Folding  --  Utility  Functions  for  Normalized  Text  Matching  --  Extreme  "Normalization":  Taking  Out  Diacritics  --  Sorting  Unicode  Text  --  Sorting  with  the  Unicode  Collation  Algorithm  --  The  Unicode  Database  --  Finding  Characters  by  Name  --  Numeric  Meaning  of  Characters  --  Dual-Mode  str  and  bytes  APIs  --  str  Versus  bytes  in  Regular  Expressions  --  str  Versus  bytes  in  os  Functions  --  Chapter  Summary  --  Further  Reading  --  Chapter  5.  Data  Class  Builders  --  What's  New  in  This  Chapter  --  Overview  of  Data  Class  Builders.
■5058  ▼aMain  Features  --  Classic  Named  Tuples  --  Typed  Named  Tuples  --  Type  Hints  101  --  No  Runtime  Effect  --  Variable  Annotation  Syntax  --  The  Meaning  of  Variable  Annotations  --  More  About  @dataclass  --  Field  Options  --  Post-init  Processing  --  Typed  Class  Attributes  --  Initialization  Variables  That  Are  Not  Fields  --  @dataclass  Example:  Dublin  Core  Resource  Record  --  Data  Class  as  a  Code  Smell  --  Data  Class  as  Scaffolding  --  Data  Class  as  Intermediate  Representation  --  Pattern  Matching  Class  Instances  --  Simple  Class  Patterns  --  Keyword  Class  Patterns  --  Positional  Class  Patterns  --  Chapter  Summary  --  Further  Reading  --  Chapter  6.  Object  References,  Mutability,  and  Recycling  --  What's  New  in  This  Chapter  --  Variables  Are  Not  Boxes  --  Identity,  Equality,  and  Aliases  --  Choosing  Between  ==  and  is  --  The  Relative  Immutability  of  Tuples  --  Copies  Are  Shallow  by  Default  --  Deep  and  Shallow  Copies  of  Arbitrary  Objects  --  Function  Parameters  as  References  --  Mutable  Types  as  Parameter  Defaults:  Bad  Idea  --  Defensive  Programming  with  Mutable  Parameters  --  del  and  Garbage  Collection  --  Tricks  Python  Plays  with  Immutables  --  Chapter  Summary  --  Further  Reading  --  Part  II.  Functions  as  Objects  --  Chapter  7.  Functions  as  First-Class  Objects  --  What's  New  in  This  Chapter  --  Treating  a  Function  Like  an  Object  --  Higher-Order  Functions  --  Modern  Replacements  for  map,  filter,  and  reduce  --  Anonymous  Functions  --  The  Nine  Flavors  of  Callable  Objects  --  User-Defined  Callable  Types  --  From  Positional  to  Keyword-Only  Parameters  --  Positional-Only  Parameters  --  Packages  for  Functional  Programming  --  The  operator  Module  --  Freezing  Arguments  with  functools.partial  --  Chapter  Summary  --  Further  Reading  --  Chapter  8.  Type  Hints  in  Functions  --  What's  New  in  This  Chapter  --  About  Gradual  Typing  --  Gradual  Typing  in  Practice  --  Starting  with  Mypy  --  Making  Mypy  More  Strict.
■5058  ▼aA  Default  Parameter  Value  --  Using  None  as  a  Default  --  Types  Are  Defined  by  Supported  Operations  --  Types  Usable  in  Annotations  --  The  Any  Type  --  Simple  Types  and  Classes  --  Optional  and  Union  Types  --  Generic  Collections  --  Tuple  Types  --  Generic  Mappings  --  Abstract  Base  Classes  --  Iterable  --  Parameterized  Generics  and  TypeVar  --  Static  Protocols  --  Callable  --  NoReturn  --  Annotating  Positional  Only  and  Variadic  Parameters  --  Imperfect  Typing  and  Strong  Testing  --  Chapter  Summary  --  Further  Reading  --  Chapter  9.  Decorators  and  Closures  --  What's  New  in  This  Chapter  --  Decorators  101  --  When  Python  Executes  Decorators  --  Registration  Decorators  --  Variable  Scope  Rules  --  Closures  --  The  nonlocal  Declaration  --  Variable  Lookup  Logic  --  Implementing  a  Simple  Decorator  --  How  It  Works  --  Decorators  in  the  Standard  Library  --  Memoization  with  functools.cache  --  Using  lru_cache  --  Single  Dispatch  Generic  Functions  --  Parameterized  Decorators  --  A  Parameterized  Registration  Decorator  --  The  Parameterized  Clock  Decorator  --  A  Class-Based  Clock  Decorator  --  Chapter  Summary  --  Further  Reading  --  Chapter  10.  Design  Patterns  with  First-Class  Functions  --  What's  New  in  This  Chapter  --  Case  Study:  Refactoring  Strategy  --  Classic  Strategy  --  Function-Oriented  Strategy  --  Choosing  the  Best  Strategy:  Simple  Approach  --  Finding  Strategies  in  a  Module  --  Decorator-Enhanced  Strategy  Pattern  --  The  Command  Pattern  --  Chapter  Summary  --  Further  Reading  --  Part  III.  Classes  and  Protocols  --  Chapter  11.  A  Pythonic  Object  --  What's  New  in  This  Chapter  --  Object  Representations  --  Vector  Class  Redux  --  An  Alternative  Constructor  --  classmethod  Versus  staticmethod  --  Formatted  Displays  --  A  Hashable  Vector2d  --  Supporting  Positional  Pattern  Matching  --  Complete  Listing  of  Vector2d,  Version  3  --  Private  and  "Protected"  Attributes  in  Python  --  Saving  Memory  with  __slots__.
■5058  ▼aSimple  Measure  of  __slot__  Savings  --  Summarizing  the  Issues  with  __slots__  --  Overriding  Class  Attributes  --  Chapter  Summary  --  Further  Reading  --  Chapter  12.  Special  Methods  for  Sequences  --  What's  New  in  This  Chapter  --  Vector:  A  User-Defined  Sequence  Type  --  Vector  Take  #1:  Vector2d  Compatible  --  Protocols  and  Duck  Typing  --  Vector  Take  #2:  A  Sliceable  Sequence  --  How  Slicing  Works  --  A  Slice-Aware  __getitem__  --  Vector  Take  #3:  Dynamic  Attribute  Access  --  Vector  Take  #4:  Hashing  and  a  Faster  ==  --  Vector  Take  #5:  Formatting  --  Chapter  Summary  --  Further  Reading  --  Chapter  13.  Interfaces,  Protocols,  and  ABCs  --  The  Typing  Map  --  What's  New  in  This  Chapter  --  Two  Kinds  of  Protocols  --  Programming  Ducks  --  Python  Digs  Sequences  --  Monkey  Patching:  Implementing  a  Protocol  at  Runtime  --  Defensive  Programming  and  "Fail  Fast"  --  Goose  Typing  --  Subclassing  an  ABC  --  ABCs  in  the  Standard  Library  --  Defining  and  Using  an  ABC  --  ABC  Syntax  Details  --  Subclassing  an  ABC  --  A  Virtual  Subclass  of  an  ABC  --  Usage  of  register  in  Practice  --  Structural  Typing  with  ABCs  --  Static  Protocols  --  The  Typed  double  Function  --  Runtime  Checkable  Static  Protocols  --  Limitations  of  Runtime  Protocol  Checks  --  Supporting  a  Static  Protocol  --  Designing  a  Static  Protocol  --  Best  Practices  for  Protocol  Design  --  Extending  a  Protocol  --  The  numbers  ABCs  and  Numeric  Protocols  --  Chapter  Summary  --  Further  Reading  --  Chapter  14.  Inheritance:  For  Better  or  for  Worse  --  What's  New  in  This  Chapter  --  The  super()  Function  --  Subclassing  Built-In  Types  Is  Tricky  --  Multiple  Inheritance  and  Method  Resolution  Order  --  Mixin  Classes  --  Case-Insensitive  Mappings  --  Multiple  Inheritance  in  the  Real  World  --  ABCs  Are  Mixins  Too  --  ThreadingMixIn  and  ForkingMixIn  --  Django  Generic  Views  Mixins  --  Multiple  Inheritance  in  Tkinter  --  Coping  with  Inheritance.
■5058  ▼aFavor  Object  Composition  over  Class  Inheritance.
■588    ▼aDescription  based  on  publisher  supplied  metadata  and  other  sources.
■590    ▼aElectronic  reproduction.  Ann  Arbor,  Michigan  :  ProQuest  Ebook  Central,  2026.  Available  via  World  Wide  Web.  Access  may  be  limited  to  ProQuest  Ebook  Central  affiliated  libraries.  
■655  4▼aElectronic  books.
■77608▼iPrint  version▼aRamalho,  Luciano▼tFluent  Python▼dSebastopol  :  O'Reilly  Media,  Incorporated,c2022▼z9781492056355
■7972  ▼aProQuest  (Firm)
■85640▼uhttps://ebookcentral.proquest.com/lib/baekseok-ebooks/detail.action?docID=6943475▼zClick  to  View

미리보기

내보내기

chatGPT토론

Ai 추천 관련 도서